{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda2/lib/python3.7/site-packages/pandas_datareader/compat/__init__.py:7: FutureWarning: pandas.util.testing is deprecated. Use the functions in the public API at pandas.testing instead.\n",
      "  from pandas.util.testing import assert_frame_equal\n"
     ]
    }
   ],
   "source": [
    "from pandas_datareader import data as datareader\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from datetime import timedelta, datetime\n",
    "import math\n",
    "import random\n",
    "from itertools import combinations\n",
    "import scipy.stats as ss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.ensemble import BaggingClassifier\n",
    "from sklearn.metrics import confusion_matrix, classification_report, accuracy_score\n",
    "from sklearn.metrics import r2_score, matthews_corrcoef, f1_score, mean_absolute_error\n",
    "from sklearn.model_selection import BaseCrossValidator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import shap"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from mlfinlab.microstructural_features import get_roll_measure, get_roll_impact\n",
    "from mlfinlab.microstructural_features import get_corwin_schultz_estimator, get_bekker_parkinson_vol\n",
    "from mlfinlab.microstructural_features import get_bar_based_kyle_lambda, get_bar_based_amihud_lambda, get_bar_based_hasbrouck_lambda\n",
    "from ta import add_all_ta_features\n",
    "from ta.utils import dropna\n",
    "from mlfinlab.features.fracdiff import frac_diff_ffd\n",
    "from utils import get_meta_barier, getDailyVol"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from mlfinlab.backtest_statistics import sharpe_ratio\n",
    "from mlfinlab.backtest_statistics import probabilistic_sharpe_ratio\n",
    "from mlfinlab.backtest_statistics import deflated_sharpe_ratio\n",
    "from mlfinlab.backtest_statistics import information_ratio\n",
    "from mlfinlab.backtest_statistics import minimum_track_record_length\n",
    "from mlfinlab.backtest_statistics import drawdown_and_time_under_water"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from yahoofinancials import YahooFinancials"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "np.random.seed(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Modeling and Training Routines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_model():\n",
    "    clf=RandomForestClassifier(n_estimators=1,\n",
    "                               criterion='entropy',\n",
    "                               bootstrap=False,\n",
    "                               class_weight='balanced_subsample')\n",
    "    clf=BaggingClassifier(base_estimator=clf,\n",
    "                         n_estimators=100,\n",
    "                         max_features=1.)\n",
    "    return clf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_and_evaluate_n_times(X_train, Y_train, X_test, Y_test):\n",
    "    mmcs, pred_prs = [], []\n",
    "    for n in range(N_SAMPLES):\n",
    "\n",
    "        clf = create_model()\n",
    "\n",
    "        clf.fit(X_train, Y_train)\n",
    "        pred = clf.predict(X_test)\n",
    "        pred_pr = clf.predict_proba(X_test)[:, 1]\n",
    "\n",
    "        mmcs.append(matthews_corrcoef(Y_test, pred))\n",
    "        pred_prs.append(pred_pr)\n",
    "    return mmcs, pred_prs\n",
    "\n",
    "def visualize_mmcs(mmcs):\n",
    "    plt.figure()\n",
    "    plt.title(str(np.mean(mmcs)))\n",
    "    plt.hist(mmcs)\n",
    "    plt.axvline(np.mean(mmcs), color = 'red')\n",
    "    plt.show()\n",
    "    \n",
    "def backtest_predictions(pred_prs, P_test):\n",
    "    bagging_strategies, bagging_returns = [], []\n",
    "    for pred_pr in pred_prs:\n",
    "        signal = [-(1-p) if p <= 0.5 else p for p in pred_pr]\n",
    "        bagging_strategies.append((signal * P_test).cumsum())\n",
    "        bagging_returns.append(signal * P_test)\n",
    "    return bagging_strategies, bagging_returns\n",
    "\n",
    "def visualize_backtests(bagging_strategies, P_test):\n",
    "    plt.figure(figsize = (15, 5))\n",
    "    for strategy in bagging_strategies:\n",
    "        plt.plot(strategy, color = 'grey', ls = '--', lw=0.5)\n",
    "    plt.plot(P_test.cumsum(), lw = 3, label = 'Benchmark')\n",
    "    plt.plot(np.array(bagging_strategies).mean(axis=0), lw = 3, label = 'Strategy')\n",
    "    plt.legend()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dataset Routines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ohclv_to_features(data):\n",
    "    \n",
    "    try:\n",
    "        frac_diff_series = frac_diff_ffd(pd.DataFrame(np.log(data['close'])), 0.7, thresh=1e-4)\n",
    "    except:\n",
    "        print('Not calculated')\n",
    "        frac_diff_series = pd.DataFrame(np.log(data['close'])).pct_change()\n",
    "        \n",
    "    # Add all ta features\n",
    "    technical_features = add_all_ta_features(\n",
    "        data, open=\"open\", high=\"high\", low=\"low\", close=\"close\", volume=\"volume\")\n",
    "    \n",
    "    data['feat_tech_volume_cmf'] = technical_features['volume_cmf']\n",
    "    data['feat_tech_volatility_dcl'] = technical_features['volatility_dcl']\n",
    "    data['feat_tech_trend_macd_diff'] = technical_features['trend_macd_diff']\n",
    "    data['feat_tech_trend_vortex_ind_diff'] = technical_features['trend_vortex_ind_diff']\n",
    "    data['feat_tech_momentum_stoch_signal'] = technical_features['momentum_stoch_signal']\n",
    "    data['feat_tech_momentum_tsi'] = technical_features['momentum_tsi']\n",
    "    \n",
    "    data['feat_afml_roll_measure'] = get_roll_measure(data['close'], WINDOW)\n",
    "    data['feat_afml_roll_impact'] = get_roll_impact(data['close'], data['volume'], WINDOW)\n",
    "    data['feat_afml_corwin_schultz'] = get_corwin_schultz_estimator(data['high'], data['low'], WINDOW)\n",
    "    data['feat_afml_bekker_parkinson_vol'] = get_bekker_parkinson_vol(data['high'], data['low'], WINDOW)\n",
    "    data['feat_afml_kyle_lambda'] = get_bar_based_kyle_lambda(data['close'], data['volume'], WINDOW)\n",
    "    data['feat_afml_amihud_lambda'] = get_bar_based_amihud_lambda(data['close'], data['volume'], WINDOW)\n",
    "    data['feat_afml_hasbrouck_lambda'] = get_bar_based_hasbrouck_lambda(data['close'], data['volume'], WINDOW)\n",
    "    \n",
    "    data['feat_stat_min_frac_close'] = frac_diff_series.rolling(WINDOW).min()\n",
    "    data['feat_stat_max_frac_close'] = frac_diff_series.rolling(WINDOW).max()\n",
    "    data['feat_stat_mean_frac_close'] = frac_diff_series.rolling(WINDOW).mean()\n",
    "    data['feat_stat_std_frac_close'] = frac_diff_series.rolling(WINDOW).std()\n",
    "    data['feat_stat_skew_frac_close'] = frac_diff_series.rolling(WINDOW).skew()\n",
    "    data['feat_stat_kurt_frac_close'] = frac_diff_series.rolling(WINDOW).kurt()\n",
    "    data['feat_stat_autocorr_frac_close'] = frac_diff_series.rolling(WINDOW).apply(lambda x: x.autocorr(), raw=False)\n",
    "    \n",
    "    FEATURE_COLUMNS = [d for d in data.columns if 'feat_' in d]\n",
    "    dataset = data[FEATURE_COLUMNS]\n",
    "    \n",
    "    dataset_normalized = {}\n",
    "    for feature_column in dataset.columns:\n",
    "        feature_i = dataset[feature_column]\n",
    "        feature_i_norm = (feature_i - feature_i.rolling(WINDOW).mean()) / feature_i.rolling(WINDOW).std()\n",
    "        dataset_normalized[feature_column] = feature_i_norm\n",
    "    dataset_normalized = pd.DataFrame(\n",
    "           dataset_normalized, index = dataset.index\n",
    "    )\n",
    "    \n",
    "    dataset = dataset_normalized\n",
    "    dataset['close'] = data['close']\n",
    "    dataset = dataset.replace([np.inf, -np.inf], np.nan)\n",
    "    dataset = dataset.dropna()\n",
    "    \n",
    "    return dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def createXY(inputs, outputs, training=False): \n",
    "    \n",
    "    def flatten_features_window(x):\n",
    "        mean = x.mean(axis=1)\n",
    "        std = x.std(axis=1)\n",
    "        low = x.min(axis=1)\n",
    "        high = x.max(axis=1)\n",
    "        open_f = x[:, 0]\n",
    "        close_f = x[:, -1]\n",
    "        return close_f\n",
    "    \n",
    "    X, Y, P, T = [], [], [], []\n",
    "    \n",
    "    # FIXED IID ASSUMPTION (up to some point)\n",
    "    if training:\n",
    "        SKIP = WINDOW + HORIZON\n",
    "    else:\n",
    "        SKIP = 1\n",
    "    \n",
    "    for i in range(INPUT_WINDOW, len(inputs)-HORIZON, SKIP):\n",
    "\n",
    "        if INPUT_WINDOW > 1:\n",
    "            window = inputs[i-INPUT_WINDOW:i].values\n",
    "        else:\n",
    "            window = inputs.iloc[i].values\n",
    "        future = (outputs[i+HORIZON] - outputs[i]) / outputs[i]\n",
    "        future_binary = 1.0 if future > 0 else 0.0\n",
    "\n",
    "        X.append(window)\n",
    "        Y.append(future_binary)\n",
    "        P.append(future)\n",
    "        T.append(outputs.index[i+HORIZON])\n",
    "\n",
    "    X, Y, P = np.array(X), np.array(Y), np.array(P)\n",
    "    \n",
    "    if INPUT_WINDOW > 1:\n",
    "        X = flatten_features_window(X)\n",
    "    return X, Y, P, T"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Metrics Routines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ar1(x):\n",
    "    return np.corrcoef(x[:-1], x[1:])[0,1]\n",
    "\n",
    "def autocorr_penalty(x):\n",
    "    n = len(x)\n",
    "    p = np.abs(ar1(x))\n",
    "    return np.sqrt(1 + 2*np.sum([((n - i)/n)*p**i for i in range(1,n)]))\n",
    "\n",
    "def smart_sharpe(x):\n",
    "    return (np.mean(x)/(np.std(x, ddof=1) * autocorr_penalty(x)) * np.sqrt(252))\n",
    "\n",
    "def calculate_all_metrics(benchmark_returns, strategy_returns, dates_array):\n",
    "    \n",
    "    res = {}\n",
    "    \n",
    "    benchmark_sharpe = sharpe_ratio(benchmark_returns, entries_per_year=252)\n",
    "    benchmark_sharpe_smart = smart_sharpe(benchmark_returns)\n",
    "    strategy_sharpe = sharpe_ratio(strategy_returns, entries_per_year=252)\n",
    "    strategy_sharpe_smart = smart_sharpe(strategy_returns)\n",
    "    psr = probabilistic_sharpe_ratio(strategy_sharpe, benchmark_sharpe, len(benchmark_returns))\n",
    "    all_strategy_sharpes = []\n",
    "    for r in bagging_returns:\n",
    "        sr_i = sharpe_ratio(r, entries_per_year=252)\n",
    "        all_strategy_sharpes.append(sr_i)\n",
    "    dsr = deflated_sharpe_ratio(strategy_sharpe, all_strategy_sharpes, len(benchmark_returns))\n",
    "    ir = information_ratio(strategy_returns, benchmark=np.mean(benchmark_returns), entries_per_year=252)\n",
    "    mtrl = minimum_track_record_length(strategy_sharpe, benchmark_sharpe)\n",
    "\n",
    "    res['benchmark_mean_returns'] = np.mean(benchmark_returns)\n",
    "    res['strategy_mean_returns'] = np.mean(strategy_returns) \n",
    "    res['benchmark_sharpe'] = benchmark_sharpe\n",
    "    res['benchmark_sharpe_smart'] = benchmark_sharpe_smart\n",
    "    res['strategy_sharpe'] = strategy_sharpe\n",
    "    res['strategy_sharpe_smart'] = strategy_sharpe_smart\n",
    "    res['probabilistic_sharpe_ratio'] = psr\n",
    "    res['deflated_sharpe_ratio'] = dsr\n",
    "    res['information_ratio'] = ir\n",
    "    res['minimum_track_record_length'] = mtrl\n",
    "\n",
    "    return res\n",
    "\n",
    "def calculate_important_features(dataset_train, cutoff_up = 0, cutoff_down = 3, visualize = False):\n",
    "\n",
    "    X_train, Y_train, P_train, T_train = createXY(dataset_train[FEATURE_COLUMNS], dataset_train['close'], training=True)\n",
    "    X_train_df = pd.DataFrame(X_train, columns = FEATURE_COLUMNS)\n",
    "    clf = RandomForestClassifier(n_estimators=100, class_weight='balanced_subsample', criterion='entropy')\n",
    "    clf.fit(X_train_df, Y_train)\n",
    "    explainer = shap.TreeExplainer(clf)\n",
    "    shap_values = explainer.shap_values(X_train_df)\n",
    "    fi0 = np.abs(shap_values[0]).mean(axis=0)\n",
    "    fi1 = np.abs(shap_values[1]).mean(axis=0)\n",
    "    fi = fi0 + fi1\n",
    "    imp = pd.DataFrame({\n",
    "        'feature': X_train_df.columns.tolist(),\n",
    "        'mean': fi\n",
    "    })\n",
    "    imp = imp.set_index('feature')\n",
    "    \n",
    "    if visualize:\n",
    "        imp.sort_values('mean').plot.barh()\n",
    "        \n",
    "    return imp, imp.sort_values('mean')[::-1][cutoff_up:-cutoff_down].index.values.tolist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_all_metrics(benchmark_returns, strategy_returns, dates_array, mmcs, pred_prs):\n",
    "    \n",
    "    res = {}\n",
    "    strategy_returns_mean = strategy_returns.mean(axis=0)\n",
    "    \n",
    "    benchmark_sharpe = sharpe_ratio(benchmark_returns, entries_per_year=252)\n",
    "    benchmark_sharpe_smart = smart_sharpe(benchmark_returns)\n",
    "    strategy_sharpe = sharpe_ratio(strategy_returns_mean, entries_per_year=252)\n",
    "    strategy_sharpe_smart = smart_sharpe(strategy_returns_mean)\n",
    "    psr = probabilistic_sharpe_ratio(strategy_sharpe, benchmark_sharpe, len(benchmark_returns))\n",
    "    all_strategy_sharpes = []\n",
    "    for r in strategy_returns:\n",
    "        sr_i = sharpe_ratio(r, entries_per_year=252)\n",
    "        all_strategy_sharpes.append(sr_i)\n",
    "    dsr = deflated_sharpe_ratio(strategy_sharpe, all_strategy_sharpes, len(benchmark_returns))\n",
    "    ir = information_ratio(strategy_returns_mean, benchmark=np.mean(benchmark_returns), entries_per_year=252)\n",
    "    mtrl = minimum_track_record_length(strategy_sharpe, benchmark_sharpe)\n",
    "    \n",
    "    df_for_ddn = pd.DataFrame.from_dict({'Date': dates_array, \n",
    "                                         'Benchmark': benchmark_returns,\n",
    "                                         'Strategy': strategy_returns_mean})\n",
    "    df_for_ddn = df_for_ddn.set_index('Date')\n",
    "    df_for_ddn['Cumulative_Benchmark'] = df_for_ddn.Benchmark.cumsum().round(2)\n",
    "    df_for_ddn['Cumulative_Strategy'] = df_for_ddn.Strategy.cumsum().round(2)\n",
    "    df_for_ddn['HighValue_Benchmark'] = df_for_ddn['Cumulative_Benchmark'].cummax()\n",
    "    df_for_ddn['HighValue_Strategy'] = df_for_ddn['Cumulative_Strategy'].cummax()\n",
    "    df_for_ddn['Drawdown_Benchmark'] = df_for_ddn['Cumulative_Benchmark'] - df_for_ddn['HighValue_Benchmark']\n",
    "    df_for_ddn['Drawdown_Strategy'] = df_for_ddn['Cumulative_Strategy'] - df_for_ddn['HighValue_Strategy']\n",
    "\n",
    "    res['benchmark_mean_returns'] = np.mean(benchmark_returns)\n",
    "    res['strategy_mean_returns'] = np.mean(strategy_returns) \n",
    "    res['benchmark_sharpe'] = benchmark_sharpe\n",
    "    res['benchmark_sharpe_smart'] = benchmark_sharpe_smart\n",
    "    res['strategy_sharpe'] = strategy_sharpe\n",
    "    res['strategy_sharpe_smart'] = strategy_sharpe_smart\n",
    "    res['probabilistic_sharpe_ratio'] = psr\n",
    "    res['deflated_sharpe_ratio'] = dsr\n",
    "    res['information_ratio'] = ir\n",
    "    res['minimum_track_record_length'] = mtrl\n",
    "    res['benchmark_drawdown'] = df_for_ddn['Drawdown_Benchmark'].quantile(.05)\n",
    "    res['strategy_drawdown'] = df_for_ddn['Drawdown_Strategy'].quantile(.05)\n",
    "    res['mmc_mean'] = np.mean(mmcs)\n",
    "    res['mmc_std'] = np.std(mmcs)\n",
    "    res['mmc_sharpe'] = res['mmc_mean'] / res['mmc_std']\n",
    "    res['model_certainty'] = abs(np.array(np.mean(pred_prs)) - 0.5) / 0.5\n",
    "\n",
    "    return res"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data reading"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "TICKER = 'DB'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "aapl_yf = yahoo_financials_tech = YahooFinancials([TICKER])\n",
    "data = aapl_yf.get_historical_price_data('2000-01-01', '2020-08-01', 'daily')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "data = pd.DataFrame(data[TICKER]['prices'])\n",
    "data = data.set_index('formatted_date')\n",
    "data_original = data.dropna()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Preparation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "WINDOW = 14\n",
    "INPUT_WINDOW = 1 # REDUCED THE CONTEXT\n",
    "HORIZON = 1\n",
    "N_SAMPLES = 25"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = ohclv_to_features(data_original)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "FEATURE_COLUMNS = [d for d in dataset.columns if 'feat_' in d]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CPCV Generation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CPCV(BaseCrossValidator):\n",
    "    # TODO: add purge \"holes\" !!!\n",
    "    def __init__(self, X, N, k):\n",
    "        self.X = X\n",
    "        self.N = N\n",
    "        self.k = k\n",
    "\n",
    "    def generate_eras(self):\n",
    "        # assuming exact division, we will cut-off small piece of time series\n",
    "        # in the very beginning\n",
    "        return np.array(sum([\n",
    "                    [i] * (len(self.X) // self.N) for i in range(self.N)\n",
    "                    ], []\n",
    "                   )\n",
    "        )\n",
    "        \n",
    "    def split(self, X=None, y=None, groups=None):\n",
    "        # removing first m items from time series\n",
    "        eras = self.generate_eras()\n",
    "        len_diff = abs(len(self.X) - len(eras))\n",
    "        comb = list(combinations(range(self.N), self.N-self.k))\n",
    "        all_splits = range(self.N)\n",
    "\n",
    "        for combination in comb:\n",
    "            train_indices, test_indices = [], []\n",
    "            for c in combination:\n",
    "                indices_train = list(np.where(eras == c)[0])\n",
    "                train_indices.extend(indices_train)\n",
    "            for t in list(set(all_splits) - set(combination)):\n",
    "                indices_test = list(np.where(eras == t)[0])\n",
    "                test_indices.extend(indices_test)\n",
    "            yield(train_indices, test_indices)  \n",
    "              \n",
    "    def get_n_splits(self):\n",
    "        comb = combinations(range(self.N), self.N-self.k)\n",
    "        return len(list(comb))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "N = 6\n",
    "k = 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "comb = combinations(range(N), N-k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 (0, 1, 2, 3)\n",
      "2 (0, 1, 2, 4)\n",
      "3 (0, 1, 2, 5)\n",
      "4 (0, 1, 3, 4)\n",
      "5 (0, 1, 3, 5)\n",
      "6 (0, 1, 4, 5)\n",
      "7 (0, 2, 3, 4)\n",
      "8 (0, 2, 3, 5)\n",
      "9 (0, 2, 4, 5)\n",
      "10 (0, 3, 4, 5)\n",
      "11 (1, 2, 3, 4)\n",
      "12 (1, 2, 3, 5)\n",
      "13 (1, 2, 4, 5)\n",
      "14 (1, 3, 4, 5)\n",
      "15 (2, 3, 4, 5)\n"
     ]
    }
   ],
   "source": [
    "for e, c in enumerate(list(comb)): \n",
    "    print(e+1, c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAD4CAYAAADhNOGaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nO2dd5hU1dnAf+/MNnbp7IJIERQEsYC4okYUG0pQg1GjJEaxf/miiRpTNH62xMSSxGi+GP2wYmJJYokFGyJ2AZHeQTpSlgWWsn33fH/cOzN32k7fae/vefa555575s57Z2fue8973iLGGBRFUZT8xZVuARRFUZT0oopAURQlz1FFoCiKkueoIlAURclzVBEoiqLkOQXpFgCgvLzcDBgwIN1iKIqiZBVfffXVDmNMRaLnyQhFMGDAAObMmZNuMRRFUbIKEVmfjPOoaUhRFCXPUUWgKIqS56giUBRFyXNUESiKouQ5qggURVHyHFUEiqIoeY4qAkVRlDxHFYGSNLbW1PP+0m3pFkNRlBjJiIAyJTc4/t7pAKy9dzwikmZpFEWJFp0RKEmnobk13SIoihIDqgiUpDP09nfSLYKiKDGgikBRFCXPUUWgJIX9Dc3pFkFRlDhRRaAkhdlrd3rbk044KI2SKIoSK6oIlKRQXOD7KhW49WulKNmE/mKVpFBW7PNEbmk1aZREUZRYUUWgJIXq/Q3e9p76pjRKoihKrKgiUJKC4Asge2XuZmpqVRkoSragikBJCs0B5qAJj3yaJkkURYkVVQRKUmhu8Y8mXlddmyZJlJCseAeeOAP2V6dbEiUDUUWgJAXPjODo/l3TLIkSkoa9sOlLqFVFoASjikBJCk32jKCkwJ1mSZSQFJVZ25Vvp1cOJSOJqAhE5CkR2S4ii0Mcu1lEjIiU2/siIn8RkdUislBERqZCaCXzuGfqMkBdRzMWd5G1nXYH7PkmvbIoGUc0M4JngHGBnSLSDzgT2ODo/jYw2P67Fng0cRGVbGDn/kYAGlo082hG4i70tRt1/UbxJ6IiMMZ8DOwMcejPwC8B5yPgBOBZYzET6CoivZMiqZIVVHQsTrcISig8MwKAVs0LpfgT1xqBiEwANhtjFgQc6gNsdOxvsvtCneNaEZkjInOqqqriEUPJIK45aSDgWytQMowChyJorkufHEpGErMiEJFS4NfAHYm8sTFmsjGm0hhTWVFRkciplAygqcXQqaSAj1aqUs9InDOCJlUEij/xlKo8BBgILLDLEfYF5orIKGAz0M8xtq/dp+Q4TS2tFGmyuczF5fipN+kageJPzL9cY8wiY0xPY8wAY8wALPPPSGPMVuB14DLbe+h4oMYYsyW5IiuZSFNLK0UFqggyFnG49eqMQAkgGvfRF4AvgCEisklErmpj+FvAGmA18Djw46RIqWQ8jc2tFOqMIHMpHwwnXG+1VREoAUTjNfR9Y0xvY0yhMaavMebJgOMDjDE77LYxxlxnjDnEGHOkMWZOqgRX0s9D76/k8qdnA9YaQaFbOH+k5RswelB5OkVTAhGBE66z2vU16ZVFyTj0EU6Jm4feX8WHK6p4btZ6GppbKC5wc/8FRwEwoLw0zdIpQRR2sLZv/Rx2rkmvLEpGoYpASZjbXl1MQ3MrxYUuCt0uepQVRX6R0v4UOpRz1Yr0yaFkHKoIlKTQ0NzqV67SaKaJzMPpQiqaE0rxoYpASQqWIrBuLiIRBivpwfmPEf3pKz7026AkhQUbd3vzDSlZgEt/+ooP/TYoSWPRZvVGyRrUNKQ4UEWgxEVriHTT5404MA2SKHGhpiHFgX4blLh4e/FWb7u8o7UIeUhFx3SJo8SKS2cEig9VBEpcXPf8XG97X4OV1rhDkd5csop7esEXj1guXqumqatXHqOKQEmY+iYr9XRpUTw5DJW00FQLzfXw7q/h0z/DcxfCghfSLZWSJlQRKDGzYONub7tDoW8W4BdH0K4SKTHTsM/Xnn63tf1mXnpkUdKOKgIlJqr2NjDhkc+8+ycN9uUUavGaFjSQIOMJlYp69uT2l0PJCFQRKDHxu6lL/fadqadDeRIpGYYnA2nj/vTKoWQUqgiUmAi81c/b4DMTuTSkOPM5/Hxru+GL9MqhZBSqCJSYcN7q1913NmOH9fLuTzha4wgyHo+yXvxyeuVQMgpVBEpMbKmp99vvXOLzFPLkGlIymEjxA82aJiQfUUWgxERjS6vf/v7GljRJosRFpNQSe7WybD6iikCJiSMO7ALAs1eOAqA5QDEoGU6k1BL7trePHEpGEU3N4qdEZLuILHb0/UFElovIQhF5VUS6Oo7dKiKrRWSFiJyVKsGV1LBsyx6e/mxt2ON/n7kegOH9rH95Y0toTyENUs1QIpmGaja0jxxKRhHNjOAZYFxA3zTgCGPMUcBK4FYAERkGTAQOt1/zNxFNc5hN/OgfX3H3G0upbwo2+ayv9rkcdulQCIAJccdX56EMJtKM4KUr20cOJaOIpnj9x8DOgL73jDHN9u5MoK/dngC8aIxpMMasBVYDo5Ior5Ji1ldbgUYNzcEmn/vfWR7U9/OzhqRcJiWJGDXlKcEkY43gSuBtu90H2Og4tsnuC0JErhWROSIyp6qqKgliKMmkoTl4RrD0mz0A9OvewdtX3rG43WRSkoAqAiUECSkCEbkNaAaei/W1xpjJxphKY0xlRUVFImIoKaChyf+G8daiLayzZwtDenVOh0hKMtDFGyUEcaeLFJHLgXOA043PULwZ6OcY1tfuU7KMQNPQXz9Y7W1ffGy/wOFK1hBBERx0YvuIoWQUcc0IRGQc8EvgO8YYZ/aq14GJIlIsIgOBwcDsxMVU2ptA05Dz5u+MJgb42yUjefXH32oXuZQEcReFP1YxFMp8SQTZ8w1M/bnOIvKAiDMCEXkBOAUoF5FNwJ1YXkLFwDSxXERmGmN+ZIxZIiL/ApZimYyuM8ZoxFEWEjgjaAyxeOxh/JG9Uy2OkizKB/vaY26Bj+7z7bsKoNXxc33wMGvbcygce3X7yKekhYiKwBjz/RDdT7Yx/nfA7xIRSkkPzuyhgWsEv397GQDXnDQwyrPpU2TGM+ZXPkUw+mfw9XRobQ4eV7erfeVS2h0tKaV4Gf+XT7ztQNOQxzpw29nDIp5HwwgynF98DXu3gssFN6+Ej+6H026HtR9BS5M1pn6Pb3yfY9Ijp9JuaIoJxcvyrXu97VCmoB5lbdiXleyhrBwOOMJqd+oF5zxoKQVXgW9G8Ox3fOPXa8rqXEcVgRKSUAFl1fs1M2VO4yr0rRE4y1Z+/EB65FHaDVUESkhCKQIlx3G5Q68RKDmPKgIlJPM3+hYIF27a3cZIJWdwuaG5Lt1SKGlAFYECwCer/NN8/GPmBr5av5MBt0xl6kLNUZ8XfP0BbFkADw9PtyRKO6OKQAHg0ieD4/7eWGApgP/7eA0ALnUHyg92rfPfF5cGleU4qgiUqHn+muOjHqv3jRyh1xFWorrGfemWREkhqgiUsMxe65d9nEMqOkb1Oq1HkEN4Iorra9Irh5JSVBEo7NjX4G0f1tuXWXTplj1+48qKtcZQ3tGhm7VVRZDTqCJQqLznfW/76P5d+f6o0NlFSwpUEeQdniR1LRpDksuoIlD8aG01frMCD5MvPQaXrhbnF2N/a0UbA7RqXEkuo4pA8WPiqP4UuoO/FmcefkAapFHale9O9t8vKrNST4AGmuU4qggUL6VFbkb06xpSESh5wPCL/fdFHDMCVQS5jP7iFbp0KATAZbv7FLoTNwGp+2iO4FEEWlYkp1FFkOds3FlLTZ2VethTcbQowRmBaCLqHEFAbAcBnRHkNKoI8pzvPeZLMeypS6OmIcWLLhbnBRF/8SLylIhsF5HFjr7uIjJNRFbZ2252v4jIX0RktYgsFJGRqRReSZyte+q97YHlZQAUFvh/LebfMbZdZVLSyPE/9rVFdLE4T4jm0e8ZYFxA3y3AdGPMYGC6vQ/wbayC9YOBa4FHkyOm0h48PqkSgKq9DX79XUu1IE3eMO5ex44uFucLERWBMeZjYGdA9wRgit2eApzn6H/WWMwEuoqIVjbPAn41bih9unYANLmcYtP/BF0szhPirVncyxjjyU28Fehlt/sAGx3jNtl9msc4A/l89Q5vu6TQ5WhrBHFec9NSqN0BFYfC9uVWn84IcpqEi9cbY4yIxOwsKCLXYpmP6N+/f6JiKHHwxsJvvO3DD+zibRc71ghuPydysXolx+jSx/oD34xgf3X65FFSTrzuIds8Jh97u93u3ww4E9X0tfuCMMZMNsZUGmMqKyoq4hRDSYT6Jp8nyKiB3b1tTyqJAT1KuWr0wLjObdBAgpzAs1j89i/SK4eSUuJVBK8Dk+z2JOA1R/9ltvfQ8UCNw4SkZBivzgupo70zglA5h6JB01DnEBoZmBdENA2JyAvAKUC5iGwC7gTuA/4lIlcB64GL7OFvAeOB1UAtcEUKZFaSxMj+XZm7Ibge8fEDe/DzMw/lB8cdlAaplIyitHvkMUrWE1ERGGO+H+bQ6SHGGuC6RIVS2odDe3UKqQhcLuH60wanQSIl4/DUIzhGn+lyGQ0hzVPeXrSFF7/cGHmgopT1BF3zyWlUEeQhdY0t/Pdzc737028ek0ZplIzHXQQt6j6ay6giyENmrfV3BYy2FrGSp7gLtEJZjqOKIA/pWJxw+IiST7iLoLUp3VIoKUQVQR5S15T6dAHqdZhD7FwLS16FZW/CM+ekWxolBeijYZ7Q2mp4ae4mzhvRh0ufnA3AXecOY4CdcTSZaBhBjuGZDfzzEmtb/TX0OCR98ihJRxVBnvDgtJX8dcZqVmzd6+077uAecQeNKXnM4ldgjEYa5xI5YRraUlNHa6vaItpiyufrAHjy07XePjXfKHHR0hB5jJJVZL0i2FBdywn3fsDfPlydblGSwr++3MiG6tqkn/dHpwRP5Ycc0Cnp76PkIMUBs0aXGhJyjaxXBN/U1AHw8aodEUZmPi2thl++vJDzH/08rtfvrm1k7Y79IY+VFfmnlr64sh9uLTygRMPYu/33K4akRw4lZWS9IvAwe+1O3lm8Nd1iJESzXRd2x774pt4TJ8/k1D9+6C1C7ySwxkDfbh3ieg8lD3EHVKhr1piCXCPrFcHmXXXe9l9nrEqjJInT3JKY0X65vRBc2xjsHuoKePrvWKLTeyVK9gQkENbgspwj6xXBzf9e4G1X78vuL2hzkha89zcEpwMIXEw/d/iBSXmvcOg6dA6xZb7/vi4W5xxZrwicbKmpT7cICdGSJEVQU+cfBWqMYX/ALKFTCmcEogUJcgsJuE2oaSjnyClFAFDbmL3JsSZ/vCbm19z1+hIG3DKVSU/N9vZVBawxPPrR1/z2zaUAnHW4VV66uEDrEitR0qWf/76ahnKOnFMEn2ax99BjH30d0/jV2/fyjB0f8NHKKm//ks17/MY98M4Kb/sP3xvOmt+Pj19IJf8YfaP/viqCnCPrFcF5I/xt3a0Gnv1iHdc8O4eWVsMdry1m487k++Wnmic+iTw7+PbDn4Ts/91by9i0K/Q1lxS4gxaOFaVNCkv993dvSI8cSsrIekXwn/nf+O0XF7q447UlTFu6jZXb9vLsF+u5IE6//HRyz9RlEcc0teFltLvWWifYW++/XlDoViWgxEig++i8v8Omr9Iji5ISElIEInKTiCwRkcUi8oKIlIjIQBGZJSKrReSfIlIU+UzJ44VZvqeVL7628u5v35vZXg6trSbohg0kNJOptzOMej4DD7qQq8SMuzC476XL210MJXXErQhEpA/wU6DSGHME4AYmAvcDfzbGDAJ2AVclQ9BQNDQH+8u/t3Sbtz1n/c5UvXVSeej9lRx513tB/Sc9MCOm87z83ydwzUkDAdhru5C+v2xbWy9JGZrHKIcI9fCQqHlo/w6oWpnYOZSkkahpqADoICIFQCmwBTgNeMk+PgU4L8H3CEtDc6u3/dPTg4utv7XIijTuVhriiSaD+PdXm2J+TXNLa1BfWXEBFx9reXgs22ItGA/uaeUT+sFx/Xn8ssoEpFSUJPLXSnjk2HRLodjErQiMMZuBPwIbsBRADfAVsNsY4/Hh3AT0SVTIcHy+2uchNPHYfmHH7aptYsaK7akSI2HiiX/wrI1cVNmXMYdWANC5pJCOxZbS83gKeaKMfzvhCMYO65UMcRUlcep2pVsCxUEipqFuwARgIHAgUAaMi+H114rIHBGZU1VVFfkFIViwqcbbLitqO0Dqiqe/5I/vrmhzTCZwRB//TI93vb6EnfuD3fV+bkdUL92yh9vPGcbt5wyjd5cSv0CxjTtrqW1spqTQpQnmlOSTjMCyxuzz6MtFEjENnQGsNcZUGWOagFeAE4GutqkIoC+wOdSLjTGTjTGVxpjKioqKuATwFFW58YzBFEThDfPilxvjep9U4zTBBtYTfubzdfyuDQ+in5w2mEE9O3LV6IGICKWOLKO7ahupbWyhNIKSVJSIdBvovwX47OHEzxsuJmHDLNidmb/XXCQRRbABOF5ESsVyRTkdWArMAC60x0wCXktMxPB0LLZueqcO6RmVIjhlSHwKJ9X0KPM5VoVKPLdy296gvjMOs8w8Zx1+gF+/0yuotrGF/Y3NfspBUeLCU4Pgwid9ffW7Ez9vcxiPvqfOhIeHJ35+JSoSWSOYhbUoPBdYZJ9rMvAr4GcishroATwZ9iQJ0tBkLZgWF7qiSpmQqWUZ99T50mK0hHC3WbS5JqivsaWV4X27hDzfn75n/YB21zaxtaZeFYGSOC77O1SQ5PTlzXXhj5lgr0AlNSRkMzDG3AncGdC9BhiVyHmj5cCuHbiosi/dS60n6j5dO7B5d/gvVqYGUzU6PIBKbIVW3rGIHW1kU62pa6Jzh9DeUEN7W55CP/qHFfQzol/XZImq5CueGUGrI5dXMmJSQs0INKldu5PVkcXD+3XlgQuH07NzCQDv3nRym0/9niCrTKO8o880dFS/Lvz8zEO57tRBfmNem++/1LKnDUUQuCaQjhmB0UTUucWER2DQWKgY6uhMhiII4TH39+8mfl4lJrJaEQTSsbiAojae+vfWZ15m0o07a/2e/FtaDNefNjio5GRVQHT0nromuoRVBP43/kQL3sSKBi/nIAeOgB++BAWORAEdusV3rmVv+Nr7d0BrQEzM+k/jO68SNzmlCMDfpdRJ97Iib/6dTGLqIl/1pwcvGs4t37aeuAJTQ3Qu8d30jTHUtKEInIvPAF0zPKBOyVJ6Hhbf6/75Q1/7H+fDK1dbcQUtmff7zBdyThGEY+f+Rv4+c326xQhi/gbL8+KIPp05f2RfCtzWv+Sakw/2G1fvSKdR19RCc6vxUw5OCtwu1t47nqtHW65+oweXp0J0Jd9JVh6RzXPh/gHw0hXJOZ8SM3nnYD5n3U4qB3RPtxhe3llipcH4v0v90z9cVNmPjsUFHNmnCyc9MIM7XlvCZScMwBjD//xnMUDYGQFYbqS3jj+MygHdOVMjipWUkCRFsGuttXWajJR2JS9mBM7UChc+9kUaJQnGc5Pu0zXYLW/8kb3p193KBe+JGL56yhxemWstHHfu0LYed7uEcUccoPUHlNSQisyCW3w1yIPWIBr2QmtmOnxkOzmvCB774Ugev6ySU6MIJtu5v7HdPYsKC1wcXFHW5piTD63g4IqOAExf7suZ1NaMQFFSzoq3Yxu/YSY0RcirVe2o0ufMR9TSDPf2hTdvDH6NkjA5pwgCF0oP6GI9ac9YETmf0cjfTmPi5JkpkSsc9Y0tEd07u3QopKY22Lfape45SjqZ/4/ox+5YBU+dBe/c0va4wCI4HtZ9bG3nPhv9eypRk3OKYNiB/nEEnW2TyjhHKobWVsPdbyxh9fZ9Qa+fvzE4bL6lNXXul3VNLXQobFsRvL90G+uqa9kVkHzu6P4ZHCimYQSKk332THZ7hMp7rQGeQ/W2F2CRNSOmJHQ0vZIYOacIPGZLT7ZNj0nl7gmHe8d8/nU1T3+2juuemxvxfF9X7eOQX7/FmD/M4MH3VoTMBJoItY0tlERQBHW2uWrZVl9R+vd/NiZjk8npREUJwpNcrtF++OoQxmFj4b9C93sikN3FyZVLAXJREdiPok9cVsm828d6+3vZ0ccAm3cHp741YRa+Ftt5ftZX1/KXD1Zz26uLkiku9VHMCIYeYBeXeXyWt88ZjawoGY8nRsCz2HviDaHHHXSite11pLXdONt+fWaXm812ck4ReOoSlBa56RawXvDgRVYytl+9bN3MVziyejaGqPgFcMOL8/324wlK++eXG3gpTBWyuqYWOkRYI/jBcf399i89/iC6lqoiULKIquXWtsb+HZSFiW1psGe9O+zaIWs/srae/EM63UwJOacI7r/gKH5x1hBGDQyeerb15N1WgjcnTWEURlv86uVF3kIygdQ1Rp4RnHPUgX77g3t1jFkGRUkaJ/08+rE1m6zaAh/eZ+032g9fxZ3h9h1w0xL/8fV7oKgTvjxG9rbRTrniykxzaLaTc4qgW1kR1506yC8vv4fALo/7pTGGE+/7wNu/pz78U39b2U3joa4p8hpB97Ii+nbzxRn8YFT/NkYrSorpMzL6sZNPsWoLNPnnzqKwA7gLoUtfuKsGDjvX6m/YAyWdfVlO3baLtMeVtKhtV2slPnJOEbRFoHJotdcFmgO8gpZvCS4E4yFwbCx8umoH2/f6/KinLd3G3vrmiKYh8DdJedJQKEpaKO0R/dj9Ydy2CwIWfSuGAmJ5CRV3hvMnW/29R1hbTxGcHStjElWJjry6owRG7x7Uw4ra3bbHP8jlLUciuJJCF50c5SMbEgg4++GTs7josS/YUlPHdc/P5Zpn5wBQGmFGALCvwXpCGhdQkUxR2p3+x1vbyqviP0dggRt3MWCsJ/+SzlB+qNXveXhrcszENTld0skrRXBEny7euAKA0kKrPfr+GX7jDnFE+ha6XRzVz+e7vCfBVNbrqms54d4PmLrQp2wKC6L/N3x3ZJ+E3r+90DCCHKekq69qWTwEzgg86a33V1kzAo9JyGMicsYXNAaYmZSEyStFADD7tjO87XCeQi6XsHhzDQs37WZvfTM9O5WEHJcsXp27OfIgm3gWq9sbCVGwxBjDr19dxGerdwCwaFNNUICckkW43Inl/QlUBJ74gB0rrXUAz6LwWjuiuMXxAKaKIOkkpAhEpKuIvCQiy0VkmYicICLdRWSaiKyyt3FWr0gNJYVulv1mHKMHlQfdVE8+1MpH9M8vN3LO/37Kd/76GQAFKU7a5jH7tMWNZwwGYHjfDI4mboPmVsPzszZwyRNWLMS5f/2Usx76OM1SKXEj7sRqCrfl/VNb7ZttzHnK2jpnBK/+V/zvq4Qk0RnBw8A7xpihwHBgGXALMN0YMxiYbu9nFB2K3HQsLgiq3LVyq7VIvDCguE3g+vCe+iaao3wyb+sJ3rNm8dr1J0Y8z41nHMq6+872ZiPNNqYt3eZtr7LjN7bv1SChrEVcYBKYnRYFuECL41a07hN/RWEMfPmE/3ElqcStCESkC3Ay8CSAMabRGLMbmABMsYdNAc5LVMhUUFjgoqmllZo635PG1ScNDDm2Q5H/x3TUXe/xy5cWRvU+L87eEPbYHecOY919Z1PeMffD5p/9Yp23vXVPhAyUSubjcgeXmAwkMFrfc7Mv7gKdAmpkBPp2OxVBY3BOML8spUrCJDIjGAhUAU+LyDwReUJEyoBexhjPSuhWICOrohS6hIbmVuZt8KW6vfLE0IpgSK9OrLvvbL++V+ZFZ9ffa5t9vnVIj6Agt47F+RMcs7/BZ0ZIZRI/pZ2IxjTUErAG1HsEnPcY3Lw8eOy+bf77TkXwz0uDx2+aE52cSlQkoggKgJHAo8aYo4H9BJiBjJXAJ+SvXkSuFZE5IjKnqipyiuhkU+AWWo3xJqcrdEvYAi6XHHcQAJNOOCjm9+ndxVpovv2cYaypyt9FLmeup+dn+WZJraoUshNXFKahQDfPb+bCiO9DUQjz5sp3fO2BY/wVwZoZweMDA9SUhEhEEWwCNhljPJnQXsJSDNtEpDeAvd0e6sXGmMnGmEpjTGVFReSiMcnG7XLR3Gq8AWJPXX5s2LEeBeF2xf5x1TZaT03dy4rYsc/fJp7LT8aBSfzW7PBN799zrBfMXFPNMb+d5l03ULIEcUX2GgpMKd0WJ93sa3//hciuqW/eFP25lYjErQiMMVuBjSIyxO46HVgKvA5MsvsmAa8lJGGKKHAJLa2GhibrqaZ7WXASt8cvq2TKlaO8++uq/Z9CAgPRQlFnK4JQaSSG2FlFc41Ac299U0vY2dAPnphF9f5Gnv1ifTtIpiSNaExDsbiXDj3X1y4sBZdW32tPEvUa+gnwnIgsBEYAvwfuA8aKyCrgDHs/43C7hOaWVhqaw9+oxw7rxZhDfbOVT1b5m7CqovB68ZS+LC1yc+wAnyftuvvO9jOX5BqfrNrBVc98SV1jS1TusUqWEU0cQWvA/13auN24HaYgkdDupRc8CWNs63Msie+UiCSkCIwx823zzlHGmPOMMbuMMdXGmNONMYONMWcYY3YmS9hkUugWmlsNDc3WjKA4iujewECpaIK7ahtbKHAJhW4XT0wKb37KJYyB6v2NTF++nfeWbvXzzAqHZhfOMsQdeY1g7xb//VjcTUMpggOOgm/9xGprpbKkkneRxR7cLhe1jS1eN9Digsjh8gVu/7uVx+zTFs56A/lSbN4ZMdzY3Mp626R26pDwa0GqB7KMaOIIJp8S//ldLt9N34O70Ld2EDjbUBIibxVBYLRwcaH1UfzirCGhhgMEBaDtDFFQPpDtexsocmQL7d+9lMqDMirYOunsdZiCmlqMd0Zw+znD0iWSkmxcUSwWB3L1B20fn/g8/ODfvv3DJvgfLyj2zRQSiWpWgshbReAOUAQl9owgXFAZwMEV/rnQ65vafiL6ct1Opi7cQrXjCXnqT0fz4rXHxypu1rJ+534abfNbkcP89ocLj+J8RwK9NTvUHTCriCfFRN9j2j4+9Gw49EzH+Er/40UdrfeFxPIcKUHkrSIInBEU2mYfz9N7YMpqCK5F4FloDscNL8wL6utUUphX9QT+76M1XhOaUxF8r7IfD140wrv/yaodfIOk8CYAABo/SURBVLU+I5eTlFBEMg3Ney4J7xFgMCzpbM1EAD68N/HzK17y544UgDvA3u8pWiMi/OOq4/jXj04Iek2vzv6pIAJNRYHsjmKRNB+4642lgLUOM7xvFy7/1gDvsS9uPc3bvvypL9tbNCVeInkNvfZjX/ukn8M1IYLCYuG2bcF9NdFn7VXaJm8VQVsZRUcPLg85I/jf7/uX6IvkNVQbxWJyPlFc4OK160dz13cO9/b17uL7nPeqm2n2EI3XkIduB8VW3tJJoW2OLQzhav1nXXNKFvmT7CaAeKKEu5cV8T9nH8bhB3bh+4/PDFvPIJCxwzIy3VLK+OLW02hpNTwyYzUvzN7o7S+KYBLzVIxLBXvqm+hckh9eW+1C1TKrmpgxkX1/E6kzfNPi4JxF5UNgx4r4z6kEoTMCYPHdZ0X9uqtPOtibPK6p2TINLdi4O6jIijPFwq/GDU1E1Kyjd5cO9O1WSo8yf1NauFxOHpzBe+GYsXw7HywPYSZog8Wbazjqrvd4Y8E3Mb1OaQNPMflwNYmduBPIrlvaHToFlGftNiD+8ykhyVtF4PQaijULqNsluMRnGprwyGdcPPkLvzGeQDWAQT0Dcq/nCau3h0gf3AaBi/GhuOKZL7nymdgyT87baBU+91RHU5KIRFGuMpGSliHfM29vWykjbz/R/bY9evSg8rheX+i26hkssG8yK7f53/T2q73bz2Lw7o0nRxzf1Ny2qc2ZqTQwqV1beGZrL365McJIi4ffXxWUTkQJQySzUGGplU00qe/puG3V7U7uufOUvFUEdXYOoJFxBnc1NLeyevs+JjzymbfP6f64Y5/W43Xmb2orwd6Tkyx/8YiL702+xfdYFpZXxJjZ9M/vr+TSJ2fH9Jq8JZIiuOLt0Gmnk/WeMx9N7rnzlLxVBB4SSW0wfbl/hu0LHv3C6zO/r0FdRz1P7fedf2Sb404/rBeDenakKYI7rnOW9XmUZp6auiamLtwS3F/bFFQLobG5lSc+WRPVeRWbSDOzwmDvu4RpdmT9/eg+qNX4k0TJe0WQbO6ZavnMe1xH822h2IlLPHUcIqvbQrcroheWM4tp5yjzNgXWgGhsbmXHvgaG/+Y9Tn/wIwC2761n+dY9/GfeZu6Zusw7tr5J3X/jotkxG45mDSFWdq71338gfDYAJTpUESSZjbvqAJ8iOGlwfGsQucCAcsttsLxTZK+RIrf4mYY2764LemK/9IlZ3nZDhPQeHgIzn+5vaPbWkVi7Yz9H3Pkuk576knEPfeI1F3oYevs7TPl8XVTvk7eEmhHUONZi4nDTjshOrVecbPJeESS7RpgxBmMMy7bsAaw6BPnKj085hKcur+SUKNxCPYvvAFtq6jjxvg94cNpKvzHf1PhMAm2tERhjWLF1Lw3NLdTU+iuCfQ3N7Hb07Wto9v6vQpm773x9ibqdtsUfDg7uc3oJdenffrIocZO3iiCwtkCs9AzzlNuxuIApn6/jofdXAVBalLcxexS4XZw2tJc3fUdbFLpd3riMPXXWTf7dJVu9x38SkLfppyHyOHm4/vl5nPXQxwz5n3eY/LFl879gZF/Ayga7J0zqj9lrQ9uaP/+6OqL8eU1rwOzM6dXjTsH3/zK76OHBp/r6vnom+e+TR+StIkiUy8IUsh9YXsac9bu8+6XF+TsjiIW6phZmr9uJMcb7ZO6crYV6Kt8eplTo1EW+xeEv1lg3cU/Cuwse/TxsxbQ3QywqA3TukL/KPCraOyX0wafA7dVw2X/gjLutvjdu8AW5KTGTt4og0YpYhWHSJdQ1tfjdwDrFGKyWr8y34zG+WFPtnat5vI4C1wo8TPliXVDfok01IcdecpzPROFZNxjeN3SVq/d/djK3jT/Muz+ib9e2RFcCcw7tji5eIyE8Mw1n+or7B0T2YlJCkrAiEBG3iMwTkTft/YEiMktEVovIP0UkuCp8BjCyfzd7G9+P3KkIfj1+KHedayXAevqzdX7uitGYRRQfDU2t3s/M85N+e/HWkGMfmeG/aFhT28S5f/005NhDe/niGJZvteIKHp54dNC40iI3g3p24pqTD+adG0/yk0MJQ2AW0mfGt997NwZEr694u/3eO4dIxozgBmCZY/9+4M/GmEHALuCqJLxH0hk9uJx5t4/llCE943p9oSON9SEVHbn8RHVhSwZNLa0+05B9B/7pi+HXA5y0VTHOWQthb30TRQUuenT0PaMMttOAODPGetaR9CEzBBW+GVNY09C4+1IvR2mAV96y11P/njlIQopARPoCZwNP2PsCnAa8ZA+ZApyXyHukkm5l8U9WnE/60RSxV6KjsaXVe+NttRs9HP+nJXefxbLfjAPg2pP9PVY+XOEf4OfhNxOstNd/+t5wAN5dsg2X+OeY+t13j6RX52Km/nS0t8+3VqGaIIhJjhtuuLoEBQkkm4uWEZdY5S37f8vaX/BC6t8zB0l0RvAQ8EvAcyfsAew2xnhW4zYBfUK9UESuFZE5IjKnqir78ro4bw0NYXLk3Hmu5kuPlSK3y7s24AnouuQ4a2F+xT3jKCsuoIPtkvtBQGR39xCK/dFLRnLZCQMA/5iCeocJCqC8YxGzfn0Ghx/oWzfwrVUkdk05idsR0GdaYd92aAq9eJ9SXC6rvOUVb/n6GmJLdqgkoAhE5BxguzHmq3heb4yZbIypNMZUVlRE9jPPZMJFuV6h5qKYmfzxGm/94m17Gli+dQ8NzS0UuoXiAn8PrEjZTUcN6M5Zh/tSGF98bL+gMR630j7dglMhhPJeUmxcju/83Gfhj4PhhYnhx6QaESiwi9fcG/LZU2mDRFxaTgS+IyLjgRKgM/Aw0FVECuxZQV8gp+vJlXcs8gZMPTxxBDe8OD/NEmUng3p2ZPX2fcxZv4s5f/c9W4x76BMgclEb8J+ZvXbdiQzv5+8IUBbCg+vO7wzj+tMGBSkZC88agaqCIFyOz/L9O63tmoBylO1hGnLy0/nwoJ3SpWEfFOdn+vd4iHtGYIy51RjT1xgzAJgIfGCMuQSYAVxoD5sEvJawlBnMmYcf4DUxTBjRhzMOy69qZMni6cuPbfN4NNXgGh2KYNiBnaN6384lhQwsD11BSx2+2sAdzdN+O3+AnXv72tN/077vneWkIo7gV8DPRGQ11prBkyl4j7QT7is+8iD1OY+HUE/rbXHW4cEK16MIPr/ltLBxHrGgeqANoik2kw5Nevh3re3s/4P1n7f/+2cpSVEExpgPjTHn2O01xphRxphBxpjvGWMaIr0+l/jRyYekW4SspLggtq/iEfaibkNzC+urrTUFz6yha2n4p9XZt53O7ecMY9pNkQvleFDLUBZxgeO58+lvw7alcFcX2BRmKdMYeOBg+OTB9pEvQ8nbyOJECXdvcLmEy044iP86OUQyLiUsZcUFnD40+piOjbtqARjyP+8w5g8fsnLbXm+Fs7bWE3p2KuGq0QMZ3Ct8oRwPvsA21QRx0f/49n/PwJnKoydY2ydOCz1+6WtQWw3T7/bvXzUNVryTfPkyFM1/ECeDKqyFqFBpCn4z4Yj2FicnGHJAp6BiP+EILGKzeVcdjS2tuMRKdpcM1H00TroNgH7HQZe+6ZYkMv+e5Gvv+QY6H2i1n7OXOe8KnbIk19AZQZyccEgPpt88hosqg10SlfgIrB3QFpO+NSCo738/WE2YtERxERjhrERJc0P7eww5uWMnjPhh5HFrP4Geh/v2HzoSWpr8cyXtWJV8+TIQVQQJcEhFR80llESem7XB2w6X5tvDiADX0OZkagAbb4qJpJ85R+ls++831/t8+tOByw3DL/btn3iDtf1mvrVe8KGd+mLKObB9iW9cazP8aSi8dKWvr6YdEuhlAKoIlIwkVPBXWyzatDvpMvhmBKoKoqKswqpNUL8nvTMCgB6DfO2OtofZ5DHW9sN7w9c5rt0Bm2b79ndvCD0ux1BFoGQMJw7q4W0XOEocThhxIM9eOSpo/LDevliBpXaVsetPHRQ0Tmkn9m2DlgYrCV1Jmt2oOx8It26GO3dDcQjHAGchm24DQp/DVQC71qVAuMxDFYGSMYx1BOM5ZwQPTzyak0OUu3zzJ6OZf8dYAGatsZ7wxh1xQNC4RNH5QJTs3WKZVyD9MwKwIovDmW6dXkKn3ArnPxE8prTcmjk01lompXWfpUbODEC9hpSMwXnDPaBLCf/+0Ql0ayMmwOUSupZaieY8NYw7lyQvv433HqKaIHpa7AV/VwbdWkLNCDx8bwocbidIfuVq/2P7tsLcKbDmQ2v/mfE560WkMwIlYwg0xR87oDuDekb293eSzLKSGkcQgbMdQVh9Kq1ti10TIpMUwaAzYMBJoY8Nm+BrT3oDDh1n7zhmErvXW9uy+GqXZAMZ9N9S8h1PeulE8MwQkoHGEUTg2Ktg6s+sdp+RsHkO/GmItR9NCor2orgTXP6mVdO4qCP81lHMxmk6Gniy9bfnG8vr6YGA7MH7o4txyUZ0RqBkDBceYwUghUsCF45U1YXWNNQx0CXAyyuTZgQeOnTzT5ZXWBp6XOcDobQ7jLkl+FiOPhVk4H9LyVcK3S7W3Xd2zK/r3KHQu0aQTLRUZQwEZiPNREXg4a4a2DQHOkVwLDj1VssT6qunfX11uywlkWPojEDJejqVWDedRy8ZmdTzaqnKGAi88UsGmYZC0bcyuhQYgdf1wMCcfDJQRaBkPbedfRgHdC5hzJDkVrrTmPEYCLxhZtIaQSKc+msrDcVFz/r6dqxMnzwpQhWBkvWcNLiCmb8+ndKi1JgjcvABMPkEmYZyRBGUdocffw6Dxvr6HhkFe7elT6YUoIpAUcKhi8XRE1ifONeStRWVws0rfPvrP02fLClAFYGihEHQ9KNR485R05AT5+LyjtXpkyMFqCJQlDCo+2gMeKJvPWT6YnG8DLQr2334+/TKkWTiVgQi0k9EZojIUhFZIiI32P3dRWSaiKyyt92SJ66itB8aUBYDzQEVaQ89Kz1ypJpJb6RbgpSQyIygGbjZGDMMOB64TkSGAbcA040xg4Hp9r6iZB3eFBOqCcJzwZPw3cngDojo7nlYeuRpDwacBB3sWII9W2J/UtjzDcx5Gmo2QcO+5MsXB3ErAmPMFmPMXLu9F1gG9AEmAFPsYVOA8xIVUlHSQazuo7trG3n5q00YY/JHeRx5oVUExlOUJh8oP9SyG25fDg8OhTlPxfb6d26FN2+EPx8OU85NjYwxkhR/OxEZABwNzAJ6GWO22Ie2Ar3CvOZa4FqA/v37J0MMRUkJLQZu/89ihh3YmYnH9qN6fyPdSotwu3yqYn9DMyN+Mw2Am/+9gP86+WBuHZ/DT8WBfOt6KxdP90NyezYAVu6i2mqY+Yi1v/hl2LsVjrkcukRQiDvXwtL/+Pa/mWv1dR8Y/jXtgCT65CIiHYGPgN8ZY14Rkd3GmK6O47uMMW2uE1RWVpo5c+YkJIeiJJvdtY3em7uHs4/qzdSF1nOOMx3GgFumBr0+nnQZShbw4DDYszm4v+8ouHpacL+HGffCR/cF94+5xUpnEQci8pUxpjKuFztIyGtIRAqBl4HnjDGv2N3bRKS3fbw3kLsp+5ScRkIYhzxKAODTVTvaUxwlUwilBMAqcfnqj2DTV6GPz/t76P5IOY/agUS8hgR4ElhmjHEkJud1YJLdngS8Fr94ipJGIiwS3P3GEm7/z2LvbOAHx/XnjetHe4/nzTpBvnHJS+GPLXgBnjgt9DFn7YM7d8Ov7DoHdWHqJ7cjicwITgQuBU4Tkfn233jgPmCsiKwCzrD3FSXrKHT7NMERfXz1kYf0sorlrNq+j7/PXO/t31ZTz5F9u/DD4601r4G3vkV9U0s7Sau0G4PHRh4TyKppMPNvVirsu2qsxeYOXaGgg1UOM80k4jX0qTFGjDFHGWNG2H9vGWOqjTGnG2MGG2POMMak/yoVJQ5Kiwr47tHW4t/KrftYdNeZjOzflccuPYbOJcF+Fnd953AAaht8N//hd7/XPsIq6WHEJdGNe/Mma1u3y7//hvlw2u3JlSkONLJYUdrg3vOP5EdjDuHdm06mU0khr/z4RAaWl/HFrad7x3x+y2ksvOtM+nW3Cp1cc/LB3mMNza18tX4nTS2t7S670g6ccZe1HXkZTHzB/9jsx62i97s3QqfeoV/f6QAoLEmlhFGRsNdQMlCvISUXuflfC3h57iYAThlSwTNXjEqzRErS2F9tLRr3PspKsNe1P5hW+F2Ehd8r34X+xydNjIzwGlIUJTweJQDw4YoqNlTXevcz4QFMSYCyHpYSACgfDAXFUNgB3MVtvy6JSiCZqCJQlBTx8S9O9dv/8fOWW+EZD37E1VOsGbAqhBzjvL+FP3bWve0nR4yoaUhRUowxhoG3vgXABSP7emcKJw0uZ/HmGubePtab10jJcvZVwR8HWe0Tb4TPHrLad+72pbNNImoaUpQswXmTd5qLPlm1g121TVz+9JdJeZ+d+xtZX70/KedS4qRjheUeets2GHu3rz/DFb0qAkVJMx+trOL65+cmfJ6Rv53GmD98SLPDQ6m2sZnaxmY27aqlsVk9l9oNjyfQdV9a2VkznNQUeVUUxY+vfz+eyR+v4f53lvPxL06lf49SmltaeebzddwzdRlvLtxC7y5Lue3sYQm/18ZddQwsLwPguN9PZ299s/eY5j9qZyoOtf4yHFUEitIOuF3Cf59yCP918sG47KylBW4XFx/bj3umLgPg8U/W8vgna/1ed+e5wzhlSE/vjT0cra2+tb51O/Z7xzuVAFjrFboeoQSipiFFaUdcLv+bcKeSQr7+/fiw4+9+Yymn/vFDauqaqG9q4eOVVeypb+LVeZv47t8+Y+aaamatqabRYQ5asW0vALPWVPudq7xjMVX7AiqJKQo6I1CUtON2CR/94hTG/OHDsGOueXYOs9cGZ2uZOHlmUN+yLXtYuGk3F9vH/vqDo/n2Eb1xCTobUEKiikBRMoCDepTxxGWVLNpcw01jLZtyi23u+ekL85i6aEtbL/fjtfnf8Nr8b7z7xx/cw6+IjqIEoqYhRckQzhjWy6sEwJopuF3CgxcP9/Y99sNjvO0nJ1VyypAKJl96DJcefxCf/so/gM1DeccI0a5K3qMBZYqSZXhSVfTvURp07PQ/fcjXVb5Yguk3j+GQio7tJpvSviQroExNQ4qSZYRSAB6euWIUJz0wg3m3j6VbWVE7SqVkM6oIFCWH6Ne9VGMFlJjRNQJFUZQ8RxWBoihKnpMyRSAi40RkhYisFpFbUvU+iqIoSmKkRBGIiBt4BPg2MAz4vogknkRFURRFSTqpmhGMAlYbY9YYYxqBF4EJKXovRVEUJQFSpQj6ABsd+5vsPi8icq2IzBGROVVVVSkSQ1EURYlE2haLjTGTjTGVxpjKioqKdImhKIqS96RKEWwG+jn2+9p9iqIoSoaRkhQTIlIArAROx1IAXwI/MMYsCTO+Clgf59uVAzvifG0uoNefv9efz9cOev3lQJkxJmGTSkoii40xzSJyPfAu4AaeCqcE7PFxX4iIzElGro1sRa8/f68/n68d9Prt6x+QjHOlLMWEMeYt4K1UnV9RFEVJDhpZrCiKkufkgiKYnG4B0oxef/6Sz9cOev1Ju/6MqEegKIqipI9cmBEoiqIoCaCKQFEUJc/JakWQqxlOReQpEdkuIosdfd1FZJqIrLK33ex+EZG/2J/BQhEZ6XjNJHv8KhGZlI5riRUR6SciM0RkqYgsEZEb7P58uf4SEZktIgvs67/b7h8oIrPs6/yniBTZ/cX2/mr7+ADHuW61+1eIyFnpuaLYERG3iMwTkTft/Xy69nUiskhE5ovIHLsv9d99Y0xW/mHFJ3wNHAwUAQuAYemWK0nXdjIwEljs6HsAuMVu3wLcb7fHA28DAhwPzLL7uwNr7G03u90t3dcWxbX3Bkba7U5YgYnD8uj6BehotwuBWfZ1/QuYaPc/Bvy33f4x8Jjdngj8024Ps38TxcBA+7fiTvf1RfkZ/Ax4HnjT3s+na18HlAf0pfy7n80zgpzNcGqM+RjYGdA9AZhit6cA5zn6nzUWM4GuItIbOAuYZozZaYzZBUwDxqVe+sQwxmwxxsy123uBZVgJC/Pl+o0xZp+9W2j/GeA04CW7P/D6PZ/LS8DpIiJ2/4vGmAZjzFpgNdZvJqMRkb7A2cAT9r6QJ9feBin/7mezIoiY4TTH6GWM2WK3twK97Ha4zyHrPx97qn801lNx3ly/bRqZD2zH+hF/Dew2xjTbQ5zX4r1O+3gN0IPsvf6HgF8CrfZ+D/Ln2sFS+u+JyFcicq3dl/Lvvhavz0KMMUZEctrvV0Q6Ai8DNxpj9lgPeha5fv3GmBZghIh0BV4FhqZZpHZBRM4BthtjvhKRU9ItT5oYbYzZLCI9gWkistx5MFXf/WyeEeRbhtNt9rQPe7vd7g/3OWTt5yMihVhK4DljzCt2d95cvwdjzG5gBnAC1rTf8+DmvBbvddrHuwDVZOf1nwh8R0TWYZl6TwMeJj+uHQBjzGZ7ux3rIWAU7fDdz2ZF8CUw2PYoKMJaLHo9zTKlktcBz+r/JOA1R/9ltgfB8UCNPY18FzhTRLrZXgZn2n0ZjW3jfRJYZox50HEoX66/wp4JICIdgLFY6yQzgAvtYYHX7/lcLgQ+MNaK4evARNuzZiAwGJjdPlcRH8aYW40xfY2VSG0i1rVcQh5cO4CIlIlIJ08b6zu7mPb47qd7lTyRP6xV85VYNtTb0i1PEq/rBWAL0IRl37sKy/Y5HVgFvA90t8cKVn3or4FFQKXjPFdiLZStBq5I93VFee2jseykC4H59t/4PLr+o4B59vUvBu6w+w/GupmtBv4NFNv9Jfb+avv4wY5z3WZ/LiuAb6f72mL8HE7B5zWUF9duX+cC+2+J557WHt99TTGhKIqS52SzaUhRFEVJAqoIFEVR8hxVBIqiKHmOKgJFUZQ8RxWBoihKnqOKQFEUJc9RRaAoipLn/D9+XVXtquDy0QAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAD4CAYAAADhNOGaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nO2dd5xU1fXAv2dmG72DSBEQgmIBca1YUFCJJWg0BjURS2KKiab8TDTGlpjERGNM1WDF2BI1sTdUEAtdkN57X8ouZfvu/f3x3sy86bNTdt7MnO/nw+fdd9+dmfOG2XfuPfcUMcagKIqiFC6ebAugKIqiZBdVBIqiKAWOKgJFUZQCRxWBoihKgaOKQFEUpcApyrYAAN27dzcDBgzIthiKoig5xbx583YZY3qk+j6uUAQDBgxg7ty52RZDURQlpxCRDel4HzUNKYqiFDiqCBRFUQocVQSKoigFjioCRVGUAkcVgaIoSoGjikBRFKXAUUWgKIpS4KgiUBQlN2ish/nPgKbOTzuuCChTFEWJy5Q7YNYjUFQGx1yWbWnyCl0RKIqSG8x6xDqum55dOfIQVQSKouQWn0/OtgR5hyoCRVGUAkcVgaIoSoGjikBRFKXAUUWgKEpu0bl/tiXIO1QRKIqSW7RLuQ6LEoIqAkVR3E9jXaB9cFf25MhTVBEoiuJ+6g4E2pUbYM/a7MmSh6giUBTF/TQ3Bp//5bjsyJGnqCJwCR+trODP76/KthiK4k5CFYGSVlQRuISJT8zmT++vzLYYiuJOfIqg74nZlSNPUUXgMhZvqcq2CIriPnyKoLhNduXIU+IqAhF5QkR2isjiCNd+KiJGRLrb5yIifxGR1SKyUERGZkLofObCv36SbREUxX2s+dA6bp2fXTnylERWBE8B40I7RaQfcC6w0dH9ZWCI/e8G4OHURVQUpeBZO8061u3Lqhj5SlxFYIyZDuyJcOlPwM8AZ5WI8cDTxmIm0FlEeqdFUkVRCpdeR1vHbkOyK0eektQegYiMB7YYY74IudQH2OQ432z3RXqPG0RkrojMraioSEaMvMVoBSZFCabnkdbxuKuyK0ee0mJFICJtgV8Ad6bywcaYScaYcmNMeY8eGjLupKFJFYGiBNHUYB33rs+qGPlKMiuCw4GBwBcish7oC3wuIocAW4B+jrF97T6lBdQ0NGVbBEVxF0311rGoLLty5CktVgTGmEXGmJ7GmAHGmAFY5p+RxpjtwGvA1bb30MlAlTFmW3pFzn9qVREoSjA+ReAtya4ceUoi7qPPAzOAoSKyWUSujzH8LWAtsBp4FPh+WqQsAC4afqi/XVOvikBRgvApAtHQp0xQFG+AMeaKONcHONoGuDF1sQqP9qVef/tAnYbTKwor34M3fgw/nBdQBP00sjgTqHp1CU5HIQ0qUxTgvV/Cvs3wzKXQWGv1DTkXug6C3sOzK1ueoYpAURR3UmTvB2z4xKpHIB7wFNmxBJJV0fINVQSKorgT535A/UHLY0hUAWQCVQSKoriTbY541YO7oKjUcVFjbdKJKgJFUdzPtgVQs9dq66og7agicAmaVUJRQijpEGjv0lodmSSu+6iSHYwxiM58lEKmfn+gXdRGaxFkEF0RuJSmZl0iKAXMwd3B56XtNYYgg6gicCkb9lQz4NY3mb9xL/tqG5i9LlImcEXJU54MKYFSdwBK2mVHlgJATUMuQiSwV/DRCis1971vLqPZGOZvrGTpr86jbYn+lykFQOieQGMNFLfNjiwFgD5VXIRzw9i3PTBvw15/X0OjAc25peQ7vpTToeiGccZQ05BLMCF+0UWe8I3id5dsby1xFCU7NDfBr7sHzg85NtDetjDQVje7tKKKwEX07lRGn86WZ0Skn3lto2YlVfKc0OL09QcDbX+ksXrTpRtVBC7j26cPBOCtReFlHOobm1tbHEXJLoeOCLTLOmZPjjxHFYHL8NomoZlrw72EtE6Bkvc4Y2fu2AXDrwycf/2Z1penQFBF4DI8EfYGfPxxim6WKfmO4/fvLYa2XQLnXQe1vjgFgioCl+Db+6ptUPOPovhxlqb0qJNjplBF4CIEmLp8Z8wxjU2qKJQ8xlmABsBTHLjmLQ4fr6SFRGoWPyEiO0VksaPvfhFZLiILReR/ItLZce02EVktIitE5LxMCZ6vFHtje0RoGUslp6neAx/eCw21ka8/+WXr2HOYdTSOiY9TKWga6rSSyIrgKSAk3pspwNHGmGOBlcBtACIyDJgAHGW/5h8i4kVJmGJv7P+SSx/+rJUkUZQMMOufMP1+WPRi+LUmxyTn5O9Zx2ZHn8d+lGgyxrQTVxEYY6YDe0L63jPG+P6HZgJ97fZ44AVjTJ0xZh2wGtBMUS3AE+dHvqbiYMzriuJqDuywjk114deckcMdDrGOvY4K9KkCyBjp2CO4DnjbbvcBNjmubbb7whCRG0RkrojMraioSIMY+UG7Ut0QU/IZn0knwkN977rwPo8aFFqDlBSBiNwONALPtvS1xphJxphyY0x5jx49UhEjL/D9eZQW6/69kses+dA6hs7uG+vhhSvDxyutQtLTTxG5BrgQGGOMP/HHFqCfY1hfu09JABGJm0Ll9vOPbB1hFCUTVG60GyGKYPOcQPuYy1tNHMUiqemniIwDfgZ8xRhT7bj0GjBBREpFZCAwBJidupiFQ6c2Ac+IDmXhetqZnG7Gmt08/kmE5bSiuJ6QGY+z+thXJwVfu/59uPzpzItUwCTiPvo8MAMYKiKbReR64G9AB2CKiCwQkUcAjDFLgP8AS4F3gBuNMZoXoQX8aOwQf/uxq8vDrjc0WX9Am/ZUc8WjM/n1G0tp0NgCJddorA85d7iThpqN+p0Aw8ZnXqYCJq5pyBhzRYTux2OM/w3wm1SEKmTKigObYycN6uZvz/3lWMrvfd9fwnJNxQH/taZmQ7HuqSm5RGNIHMEXL1jHRKOHNYwgraiLiguZ+n+j/YFl//nOKSzcXEm3dlaofaOtCCr2B9zvtL6xkhO8e3ug3RjiPupzK71lTQJvpG6k6UYVgUtwbhIP7B6ozXriwK6cOLArYBWraWq2zEC3vBQo0rFzfx0D1e1UcTsz/hZoh64Iti+yjm06o7Q+6quYQxR5hcam8Nn/WQ9Ma31hFCUVQlcE+9S5MJuoIsghijwev2lIUXKa0BWBklVUEeQQAtRpuUolH1g9JdDW+sNZRw3LOcT+ukaembmR2euCq5ed8SWNzFZcTtXm4PPKjbB5Hjx2Nnz5/uzIpPjRFYFLMC3wh1u5I+A62qNDKftrGzIhkqKkj+kPhPdtswvVv31L68qihKGKwEUkk1yxX5c27KtRRaC4nEg/7uaQQMiRV7fgDdWclE5UEeQ4Qw/pwL5aLVajuBwTIfp908zg834nJ/Zemo467agiyGGKPELHsmJdESjuprkZ5j0V3r/45eBzTTmdNVQR5DCjh/ak2OvRXEOKu5n1cPD5hOcij2vXPfOyKBFRRZDD3HHhkXg9QrMBoy54iluZ81jweYfe4WO+NA4Gnd068ihhqCJwCwk8x/t0bhN0Xlrkxeux7KWab0hxLw6b/rj7wFsSPuSs28Gjj6Nsod+8i4i3B/bbrx4TdF7klYAi0BWB4laOvCjQPvl7kRWBtzi8T2k1VBHkEKHmnyKPUKQrAsXthJYkifTQTzT9tJIRVBHkEM2hisDrUdOQ4m4a6+Czvwb3RVoRSAsfRboCTiuqCHKI2oZg76Aij6giUNzNgggeQpEUQZsumZdFiUoipSqfEJGdIrLY0ddVRKaIyCr72MXuFxH5i4isFpGFIjIyk8LnE4k8xs8a2pPzjurlP3cqAs1KqriShurwvlDT0A/mQduurSOPEpFEVgRPAeNC+m4FPjDGDAE+sM8BvoxVsH4IcAMQ4kCsxELiVF5qU+Lln98M1DH2OhRBsyoCxY00OYIdr3/fOoauCDr1bT15lIjEVQTGmOnAnpDu8cBkuz0ZuNjR/7SxmAl0FpEITsNKOhAJbBbrikBxJU5F0O8E6xiqCNRjKOsku1XfyxizzW5vB3z2ij7AJse4zXbfNpS08c6PTqe9XZrSI7pHoLiUmkqYeq/VdnoFhaaS0NQSWSdlny1jjBGRFj+FROQGLPMR/fv3T1WMguKIQzr62z7TkKaZUFyHs/zkMV8LtJ0BM8df23ryKFFJ1mtoh8/kYx932v1bgH6OcX3tvjCMMZOMMeXGmPIePbSwSrJ8sNz66h/9eG2WJVGUEJyrgHH3RR5z0UOtI4sSk2QVwWvARLs9EXjV0X+17T10MlDlMCEpMUg2V9Cu/VYR8DUVB9MpjqKkzrzJgXZJuzS/uZpC00lc05CIPA+MBrqLyGbgLuA+4D8icj2wAbjcHv4WcD6wGqgGdN3XApJJs37K4d2YtW4Pg7qn+w9NUVLk0BGBduiG8MUPQ6+jkntfrUeQduIqAmPMFVEujYkw1gA3piqUkjgXj+jDQ++v4qRB6oetuIxY0cIjrmw9OZS4aGRxjlPktTeLG3WprLiIPevg5euzLYWSIKoIcpwSr/Vf2BBa/1VRsslfHGahSyZlTw4lIVQR5DhFPkXQqIpAcSmDw6zIistQReASkjXsFHs1slhxGc2haacjJJlTXIUmAXcRyfhCFNsrgv/N38KBukaqahq466IkvTEUJR3Uh7gyqyJwPaoIchyfIliydR9Ltu4D4M4LhyHqYqe0NsvfgkOPg9n/tM6PnQADToPisvR/ltYjSCuqCHIcX4oJJ7UNzbQp0fwtSitStx9eCPE0378VRn4zAx+mk5x0kxd7BNuqajQNs4N63ThWWpvti8P7Oh/W+nIoSZHzimDj7mpO+d2H/GPa6myLkhLpXOnWawI6JRqr34cNn6X/fdv3DO8bc2f6P0fJCDmvCLZW1QAwfdWuLEuSOsna9S8vDy7soYpAicozl8KTX07utU0NsHVB5GuhM5myzpGVg+JKcl4R+Ji9bg/vLN6ebTGygi+WwIeahpSMMP1+mHRmZDOQCfnNNTe2jkxKWsh5RbBlb42//bepq7IoSfZ4c2FwgletTaBkhM1zrOO+reHXwhRBU/gYxbXkvCL46Ytf+Nu7D9RnUZLsUVXTEHSuKwIlI6z50Do2Rfg7MyEP/vP/kHl5lLSR84rAybaq2myL4ArqVBEomaS2MrwvLIisNMNCqJdgOskrRQBQXZ+btsl0/qzVNKREZMOMlr9m9ftwdyd47aZA38GK4DFb58Pj51jt4XYsQd/y5GRMBA2WTDt5pwg+yWHvoWR/3g98bXjQuZqGlIh89peWja/eY3kZAXzuqDa2dUGwl9Di/wbax3wN7twL3Q5PXk6l1cl5RXDxiEODzpsNPD1jPd9+ei5NzYY7X13Mpj3V2RGulejdKTiEf8c+NZEpEag/EGi/fWv8Dd1pv4vcv/QVmPtE4NypYIrbgCfnHysFR87/j72yINiDobTYw52vLmHK0h2s3LGfp2ds4NKHMxBA4yKKQtJM3PLSwixJoriaddMD7VkPw5bPY4+P5B3kY+v8yP3FbVoul5J1UlIEIvJjEVkiIotF5HkRKRORgSIyS0RWi8i/RaRVUw8+P2ujvz1jzW4AdtoF3t1Kc7PhQG1D/IEtYPn2fWl9PyUP2fBp7OuVG6Jfa9fdOtbsDe7XTKM5SdKKQET6ADcB5caYowEvMAH4PfAnY8xgYC+QsXp1dY3hS9v3lu7wt+du2JOpj04rD72/kqkrKsLcQBMlUpql7z0TZ7YXhw27D6qJKd95/67Y17cvCj4/63b4lu1C6vMK2huiLESTHeYiqZqGioA2IlIEtAW2AWcDL9nXJwMXp/gZUXG6Sd40ZkjY9bcWWZHGXdoWZ0qEtPDivM0AHKhLn8fTul0H4w+KwZn3T+Ok336QJmkUV9CxT3KvO/oy61h/APoeb7XXf2IdG+yAzqEXwNm/hJ5HpCajkhWSVgTGmC3AA8BGLAVQBcwDKo0xvifaZiDJX198Plsd8BCacEK/qOP2VjcwdcXOTImRMr74h2T9/31VyhQlJpE2h6NtGFc7VtODzrSOpR0DfRs+gca6QPzAaT+CM25Jj5yJoPUI0koqpqEuwHhgIHAo0A4Y14LX3yAic0VkbkVFRfwXROCLzVX+druS2KUVrn1yDg+8uyKpz3E7xx/WJdsiKLlAcyMcdlpw3xPjIm8az38m0B42Hkb/Ak76bvCYj34PDbYiKGmXXlljohOfdJOKaWgssM4YU2GMaQD+C4wCOtumIoC+wJZILzbGTDLGlBtjynv06JGUAEf2tmYoPxo7hKIEZsUvzNmU1OdkmlTjY6JlLc2kjf/9pTtyNnivYGluhLKOwX2bZ8OjZ4WP3TLXbgiUdYLRP4fS9iFj5gVWBMVt0y6u0nqkogg2AieLSFuxnkRjgKXAVMA2KjIReDU1EaPTvtTamDpraM+EFMHoockpnEzTrV36PC1e/t6p/namVs/Ltu3jW0/P5Y5XlmTmA5T0s2+blRrCk+Bmbv9TrOMta8KvHX+NdazeHVAEJe3Dxyk5Qyp7BLOwNoU/BxbZ7zUJ+DnwExFZDXQDHk+DnBGpa7Bs6qXFHkqL4v/AfSsIt7GvJn0z6yMO6eBvJ6Ick2HvQSvp2JbK/A7UyytWT7GOdfsTG+9zC23TOfzaufdaxyHnwt71VrtEVwS5TEo1i40xdwGhPmhrgRNTed9EObRzGy4v70vXttaMuk/nNmyprIk63q2bquksJOOsYexJ0ubUGEee3bYiKPbmfDxi4VBmP9Abo2TobWoEr+NxUFNpmYQirSBK7cnGx38M9BVpIFkuk9N/ycP7deYPlw2nZ0crxcK7Pz4j5qy/tsGdOdK7t7cU2bPfOinp9/jT14dzzakDgh7+JknbUG0c76UfPm9Flbr1+1Qi4Hugb/wMLngQJjwXfP2BwcHntbYiSPj9c/pRUvCktCJwG+1LiyiJMevfX+u+zc1Ne6rZdaCeEwd2ZdTg7km/zyXH9eWS4/rS5IguS3aL4ObnA+kDqmoa6NQmchxGIuY4xSV0dSSBO+F62PZF8PXQCOHaqsAqwpWo+2g6yTs17nQpddK1XQmV1elN45AO3lxkVRebvS49UdDOtEPJLAhqG5r4YHkg5mL4Pe8xZ/0edh0IT9NxWDe1C+cMPY+AK/4N/7faOm8I8Sgbcl7weU1l5P0BN6BpqNNO3imCaOw5WM+/ZsbInZIlFmy0inwc3Sc9G9lOV1KTxKwpUi2D6SsrKL/3fV6cG+x+q3+POcbQcdDe9pzrMiDQ36lfuBmotiq2aejuKrjuXavt8zBScpaCUQQ+5q53V/6hd5ZYaTD++c0MFPJIYkXQ0BT+or9+aM0ip67YSbPD9KSmoRymQy+49m34znSo2gSL/hO4Nu8pqFgWf4+g/8nwjZfhyv/EHqe4noJQBOcM6+VvX/ZIElWaMsi5tmx9Oqff6yIZK2osjyFB+NvU1f7z0CR5ySbNU7LEYadC7+HBq4M5j8PrN1vtRPYIBo8ND1JTco68VwSPfGMkj15dzlkJBJPtOVjf6p4wxUUeBvXITHj+5r2J+/k3NRtmrNlNQ6RUpj4E3l683X/6kp0sD6yU38PveY93l2yP9ErFzRxzOSDQ3Axv/iTQ3xDdFVvJL/JOEYRG6R7SyZppT10RP5/RyF9PYcKkmRmRKxq19U20LcmMieXFuZvjD7L5+9TVXPHoTKavjP49CdHrIf/yFStl8buLVRHkHG06Aya8KP0OjRwvFPJOEQw7NHiZ2rHM8pAdd9Qh/r7mZsM9ry9h9c4DhLJgU2VYX1OsWXKK1DQ00aY4M4qgJZHFvkI2G2OU9RQRDo1iwhp7pGXiytTqRskgvkyjS/4b3D/+b60vi5IV8k4R+FwmfRG2g3pYOVDuGX+Uf8xna3bz5KfrufHZ+MVb1lQc4PBfvMWZ90/lwfdWsOdglMjMJKmub6IsQ4pAWpCl0bdJvOdA9PsTiLpi8H3f0RLgKS5m10rr+NH9gb7hV0L38BofrkHTUKeV/FME9hbpY1eXM/+Oc/z9vToGCrxHypETLQp38RYrLmHD7mr+8uFqbv/foojjkqU2gyuClriP+kw+Tfb3cOLArmFjdu6vZcwRPYPcRn2v0z/LHKb8Out4wGHWOzxCRlLXoJONdJN3isBXl6BtiZcuIfsFD14+HICfv2w9zFfsCCTgipbv5+YXFgSdJxOU9u85G4M2Vp3UNDTRJkN7BC2ZNE2z91B85rKvl4cX+pm5dg8NzYZj+wTcChtD3E1Dz5UcYEBIjYLitnDs5dmRRckKeZViAuD3lx7L8H4bI85oY828d8UwiTiJtlkaC5/iuez4vmHXauozuSKIz5KtVUGmKd8eyajB3Vn+63E8P3sj97y+1H99f20DHcoCKSd8Kwift1Uy34+SZTwhjwGtO1xw5N2KoEu7Em48a3BEW3Voly+HjjGGUfd96O/fVxt91h8ru2ky1DSkf4+ge3ursHgiK4IL/vIJY/74UVh/WbGHsmIv144ayPr7LqC0yEOfzm3YX9tIh7LAg6PJXgFU2SuldGZSVVoJERjxjcD5xIyVEFFcSt4pgliEKodm+0nZGOIVtHxb9JztoWNbwierdrFzfyDHy5SlO9hf25h209CQntYGebRkcT7qGqPHTIRGDZ84sCs9OpTaK4Iif1xGQ7P14PcFk8VyP1VcjLPUpDNBnVIQFJQiCI3e9SVNCy3p+JadCA6smXGH0sAMuC6FgLNvPD6Lyx+ZwbaqGm587nO+/bRVDrBtmlcEd140DIAje3eIOa5if3giOR+lRZ6w8/rGZntFUMxYOyLa51pbayuV5dsTLHyiuAt/aUpaln5ayQvybo8gFkf36UTHsiL22emo2xZbt3/a76cGjTvc4Qtf7PVwbN9OfLp6N4D/tcmyfnc1p/zuw6C+4qL06mOfqak5jm2oOYYVx+MJXj2VFHmobWiiur6JDmVFFNv5530rpEg5ipQcYss86yhezSZYgBTUigBg9u1j/e1o9myPR1i8pYqFmyvZX9tIzw5lEceli/99viWt7+e1/5DjmevjKQonRR4Pa3dZ9WnblRT5FcXG3ZYrri9HUdco9ZeNMfzif4v4dPUuABZtrvKXvFRcQIm9ejS5UmxIJx7pJCVFICKdReQlEVkuIstE5BQR6SoiU0RklX3ski5h00FZsZdlvxrHaYO7h3m4nPEly+797zmbuPCvn/CVv30KQJEnszOkA3XpLZjjKxbVHGc/ozHWkiCE1xdu9beLvMK6XZab6RWPzrTfyw5IO1jPG46xgc8yPDdrI1c9NguAi/72Cec9ND3hz1cyzPXvWcdL/pldORJBVyxpJ9UVwZ+Bd4wxRwDDgWXArcAHxpghwAf2uatoU+KlfWlRmM/7Stu+vTCkuE3o83RfbUPcur4+YrlT+vYsXv3BqITeK1F85Srjzfjr4pSkdOJ8q+r6pqDN5L0H64O+sx88N59Qpizd4W+vsuM3dsbYo1BamV7DrBoDwydkWxIlCyStCESkE3AG8DiAMabeGFMJjAcm28MmAxenKmQmKC7y0NDUHJQ6+VunD4w4tk1J8Nd07N3v8bOXFib0OS/M3hj12p0XDWP9fRf43T3ThS/dQ1McRVAfRRHcct7QmK/ziNDOsYH+4rxNMUZbPD1jvb+9PWRzXlGU7JLKimAgUAE8KSLzReQxEWkH9DLG+NxutgO9or5DFin2CHWNzczfGKjVet2oyIpgaK8OrL/vgqC+/85PzK6/3zb7nHp4t7Agt/almdmr968I4piGQhXBd84cxIOXD+f7o2O7D36yuiKoJOZv31oeNiZ0xXSwLmB7zmQSP0VRWk4qiqAIGAk8bIw5DjhIiBnIWAl8Iv7Vi8gNIjJXROZWVLS+73mRV2g2xj97LvZKmKeMj6tOOgyAiacc1uLP6d3J2mi+48JhrK04mKS0LcN3T/Get6ExER3LivnqyL5xE8fdeNZgv7KJRm2IknHmenpuVmCVFE9ZKYqSeVJRBJuBzcaYWfb5S1iKYYeI9AawjzsjvdgYM8kYU26MKe/RI37RmHTj9XhobDb+h+ET15wQdaxPQXg9Lf+6quutmXDXdiVhBeAzNTP26bN479+SdBDO1cuph3cn3v65MxYDYO2uQMrv9xz7BTPX7ub4X0/x7xsoitL6JK0IjDHbgU0i4jMojwGWAq8BE+2+iYAr49WLPEJTs6GuIbrb46NXlzP5uhP95+t3B8/oQwPRIlFjK4JIaSSGHhI74CtZPJ7ENotDFUUsxfG/758a8TOcOAvs7HbkbqptaIq6GrrysVnsPljP0zM2xJRVUZTMkarX0A+BZ0VkITAC+C1wH3COiKwCxtrnrsPrERqbmv1pFiI9qM8Z1oszvxRYrXy8KtiEFSsy14cvGVvbEi8nDAh40q6/74Igc0k6CcQRxHMfTVwR9O3SNug8kmlo2v+N9rdr6hu5/qk51NQ3pd09VlG0HkF6SUkRGGMW2OadY40xFxtj9hpjdhtjxhhjhhhjxhpj9qRL2HRS7BUam43fhTI0pUIkQgu9JGJaqa5vosgjFHs9PDYxuvkpnSS6RxBqjomVMK4k5PtxKjUfPTuW8ey3TgLgLx+u5oPlO3lv6faEitqra7iSOPpjSTcFF1nsw+vxUF3f5HcDDU2yFonQ0o8+s08snPUG4iWBSxe+h2o809AD760MOl9bEV6604dPufiC6wb3jGzW8oaYjOobm9lgm9R8ieoiyhxTUkVRMknBKoLQaOHSYuuriOVDHxqAtqc6foqEnfvrKPEGvub+XdtSflhmg60TMQ1Fqsh278XHxHzfuy8axps3ne4//+rIPuGf7QldNRn/iuCOC4fFfH9FUbJDwSqC0AdWmb0iiBZUBuGF2WsbYpuG5qzfw5sLt7HbkVPnzZtO44UbTm6puC3CH1AWQxFEMgP16BA7sO2aUQODNrjvvfjoqJ/tY8Oeg/54Bad56f7Ljg1SJL48RoqitD4FqwhCVwTFttnHN3sPTVkN4ZursfL5A9z8fHiqhQ5lxRR5M/u1++IAotVhBrjq0VlRryVK25KAS6nv+9wfkp31nx+t9ZvQnIrga+X9ePDyEf7zj1ftYt4GV24nKUreU5Ss2r0AABpSSURBVLCKwBti7/c9PEWEZ64/if9895Sw1/TqGDxjjleftzKBTdJM4fVIzBQTczcEIqqfuvYEPv5ZasXKl/16HABbI1Rwu9sudVla5GV4305cc+oA/7UZt53tb1/zxJyUZFAKiH1boCq9WXsLmYJVBLEyip42pHvEFcFfrxgZdB7Pa6g6gc3kTOEViZuG2seIfp3p17Vt/IFR6NO5DcX2KufI3h2jjist8vDqD07j7q8c5e/r3SnwPe9XN1MlURpr4U+655QuClYRJBMl3LVdCb+84Eie/7Zl40+0Pu85w1o/3VJ9UzNPfLouobGp5DyacdvZvP2jwAbyiH6d/e0rTuwXNLYkjknMVzEuE8SqQ60ohU7BKgLnimDxPecl/LpvnT7InzyuodEyvXyxqTKsyIrTPv/zcUekImrSRMsuGkoqexa9O7WhY1mwW+yfJ4zg7ZtPp1u7YFNatFxOPpzBe9GYunwnHy7fEXeck8Vbqjj27vd4/YvwOglKDqJBJ2mnYBWB07ulpTNir0fwSMA0NP7vn/L1STOCxjhz/Q+2i8kXCuNH9OHI3h1ZvTN6XEIkQjfjI3HtU3O47qm5ccc5mb+pEsBfHU1RlGAKVhEctO3Rpw3untTri71WPYMv7IfMyh3BD72DOWLvvuqk/hl7b+fE7d0fnRF3fEOcFYwzU2ksj6hQfKu1F+bEr5sA8Of3V4WlE1FcSk1ltiXICwpWEdTYOYBGJhncVdfYzOqdBxj/90/9fU73x10HcqMe728uiR1ElgrO/E2xEuw9PrEcSGDzvSGw+d6SjeUVLcxs+qf3V/LNx2e36DVKK2Icv5OZD2dPjjyiYBWBj1SsjR8sD86wfenDM/w+8wfq3Ls52ZLZdDo+576vxlY2Y47sxeCe7WmI447rXGV9lqCZp6qmgTcXbgvvr24Iq4VQ39jMYx+vTeh9lSzS4HBR/ug+qNb4k1QpeEWQbu590/KZ97mOZmujOBZrWqlAji9DaWi0cSSKvZ64XljOLKYdE8zbFFoDor6xmV0H6hj+q/cY8+BHAOzcX8vy7ft4Zf4W7n1zmX9sbUP23H+VGOxeE3z+h+jZAJTEUEWQZjbttWYrPkVw+pDk9iAyyeOfJOZWmioDulspObrHSV0BUOKVINPQlsqasBn7Nx8LREPXxUnv4SM08+nBukZ/HYl1uw5y9F3vMvGJOYx76GO/udDHEXe8w+TP1if0OUorsmtFtiXIOwpeEaTbSGKMwRjDsm37gOBiLdngK3/7JEJv65iGvj/6cJ64ppzRCbiF+jbfAbZV1TDqvg95cEpwdtStVYFCQLH2CIwxrNi+n7rGJqqqgxXBgbpGKh19B+oa/f9XkbwS73ptibqdKnlPwSqC0NoCLaVnlFlu+9IiJn+2nofeXwUE5+PJBgs3V4X1NduT6UMyVBjHR5HXw9lH9IpbAxlsRWDHZeyrsR7y7y7Z7r/+w5C8TTdFyOPk4wfPzee8h6Yz9JfvMGm6ZfO/dGRfwMoGuy9K6o/Z6yLbmj9bszuu/EorcrVd9HCQIy3KvKeyIkq+ULCKIFWujlLIfmD3dkF5fNqWZndFEAlfnQI3xeXUNDQxe/0ejDF+uZzrlkiz8p1RSoW+6aiXPGOt9RD3Jby79OHPolZMeyPCpjJAxzbZVeZKCINGwx274epXYOw9Vt/rN0PN3livUmJQsIog1YdgcZRo3JqGpqAHWIcU0jdkCl+AlYv0AAtsmWas3e2Xy+d1FLpX4GPyjPVhfYsirIAgOF7Ct28wvG+niGPf/8kZ3H7+kf7zEX07RxynZBGv/XdV4kgN//sBWsIySVJWBCLiFZH5IvKGfT5QRGaJyGoR+beIhFeFdwEj+3exj8n9kTsVwS/OP4K7L7ISYD356fogd8VEzCKtjS/i94Jje2dZknDqGpoDabTtvrcXb4849u9Tg71HqqobuCjingh8qVcgjmH5diuu4M8Tjgsb17bEy+CeHfj2GYN4x86hpI8WF1MfEr2+4u3syJHjpGNFcDOwzHH+e+BPxpjBwF7g+jR8Rto5bUh35t9xDqOH9kzq9cWONNaH92jPNaNyz4Xt6lMGZFuEMBqamgOmIfsJfNML0fcDnMSqGOeshbC/toGSIg/d2gfmKEPsNCDOjLG+fSSdZLqYtiFeectey44cOU5KikBE+gIXAI/Z5wKcDbxkD5kMXJzKZ2SSLu2SX6w4Z/qJFLFvbR75xsi4YxLx729t6pua/Q9e315GN8f/05J7zmPZr6zaBzecMSjotdNWBAf4+fjVeCvt9R+/NhyAd5fswCPBOaZ+c8kx9OpYyps3nebvC+xVqCZwLSOugitfhP6nWudfPJ9deXKUVFcEDwE/A3xPwm5ApTHGtxu3GQgvbAuIyA0iMldE5lZU5F5eF+ejoS5Kjpy7LspevvQ2Id5KWyprwiKKY9VkyBYlXo9fTl9A11UnWRvzK+4dR7vSItrYLrkfhkR2d42g2B++aqR/5eOMKah1mKAAurcvYdYvxnLUoYF9g8BeRWr3pGQQjwe+dC5c+1agr65lyQ6VFBSBiFwI7DTGzEvm9caYScaYcmNMeY8e8f3M3Uy0KNdrs2gucj7kr3x0JqPu+5BnZm0MGlNa5D6PpknT1/rrF+/YV8fy7fuoa2yi2Cth8sbLbnrigK6cd9Qh/vOvn9AvbIzPrbRPl/BCRJG8lxSXIgJFtjv07yLOPZUYpLIiGAV8RUTWAy9gmYT+DHQWEd90tC+Q1/Xkurcv8QdM/XnCiDijWw+nIvD5wc8J8ZN3k2urL1X33A17+c6/AnOLcQ99zD+mrUko7sO5Mnv1xlH857unBNVAaBfBg+uurwxj6v+NjqIU49d+VlzETQsCbV0VtIikFYEx5jZjTF9jzABgAvChMeYqYCpwmT1sIvBqylK6mHOPOsRvYhg/og9jj2z9amSRiFRsJnRPwE2moSevOSHm9USqwTkL8Qw7NHrJTCcdy4oZ2L1dxGsudPhSYtHR4QX3wa+yJ0cOkok4gp8DPxGR1Vh7Bo9n4DOyTrRnxMjD3OFzHukh7wl5srnJtTXSbD0W5x0VrnB9iuCzW8+OGufREtzz7SgJc9Ql1nH2P2HDZ9mVJYdIiyIwxkwzxlxot9caY040xgw2xnzNGFMX7/X5xHfPODzbIgBQ5A1/jHk90OhCDyewCtu3hKPtTd26xiY27Lb2FHyrhs5to2cmnX37GO64cBhTfhy/UI4PtQzlEJc65p1Pfhl2LIW7O8HmKFuZxsAfBsHHD7aOfC6lYCOLUyXas8HjEa4+5TC+E+La2NpEmhF7PRLVwynbtCstYswRicd0bNpbDcDQX77DmfdPY+WO/f4KZyUxVgM9O5Rx/WkDGdIreqEcH4HANtUEOYMnZK/n4VOs42NnRx6/9FWo3g0f3BPcv2oKrHgn/fK5FPflP8gRBvewNjcjpSn41fijW1ucMCLFCHgkoAju+cpRrS1SXIYe0iGs2E80QovYbNlbQ31TMx6JvD+SDOo+WgC8ODHQ3rcVOh5qtZ+1tznvjpyyJN/QFUGSnHJ4Nz746ZlcXh7ukugGij3h/7Vtir3UNVq++S01xbQGobUDYjHx1AFhfX/9cDVR0hIlRWiEs5Ij3LkHRnwj/rh1H0NPx4TooWOgqQEqHbWtd61Kv3wuxH1Pgxzi8B7tXbXh6iTSHoEhUNCltNh9//XPOuIcoqX59jGiX/CmfGM6NYCNP8VE2t9ZySgeLwz/euB81M3WcesCa79g2n3W+eQLYeeSwLjmRvjjEfDSdYG+KodSyGPc9zRQ0kIkRVDX2MS+WmvW7cZgMieRgr9isWhzZdplCKwIVBXkHN0GB9rtbQ+zSWdax2m/i17nuHoXbJ4dOK/cGHlcnqGKIE8pimAaqqxu4GCdZRrqlGDN39Zk1OBu/rZT/vEjDuXp604MGz+sdyBWYKldZewHZw0OG6cUIB0Phdu2wF2VUBrBMcBZyKbLgMjv4SmCveszIJz7UEWQp0RaEbyxcBtNtgmlxIV7BOc4gvGcK4I/TziOMyKUu3zjh6ex4M5zAJi11prhjTv6kLBxqaLrgRyltH30qECnl9Do2+Crj4WPadvdWjnUV1smpfWfZkZOF6BeQ3lKNBfKRrtOpRszjzofuId0KuPF755ClxgxAR6P0LmtlWjOV8O4Y1n6Vjr+Z4hqgtwm0orAx9cmw1F2guT/fiv42oHt8PlkWDvNOn/q/Lz1InLftFBJC2XF3qA0y2OO6MnRfTr6VwRuSi/hI9QUf8KArgzuGd/f30k6y0pqHEGeMHgsDDg98rVh4wPtia/Dl8bZJ46/j8oN1rFdcrVLcgFdEeQxr//wNM56YBpgrQAWb9nH9ZPn+s/dhi+9dCr4VgjpQOMI8oTSDnDNG1ZN45L28GtHMRun6WjgGda/fVutTKZ/CMkefDCxGJdcRFcEeYyzitqO/cGZPiJtJmeby463UkJHSwIXjUzVhdY01HlGmy7gdZgOi9tGHtfxUGjbFc68Nfxans4KdEWQxzj3CepDUku4cUVQ7PWw/r4LWvy6jm2K/XsE6URLVeYpd1fB5rnQIY5jwVm3wYEdMO/JQF/NXktJ5BnumxYqacOZb6gkxIvIjYogWTqUWfOZh6+KX56zJWipyjymbzl06ht/nCdkrvyHgXk5M1BFkMc4XUhDk9C5cbM4WW6/4EgO6VjGmUPTW+kuf74hJWnO+oWVhuLypwN9u1ZmT54MoYogj3E+/EMVQT6tCE4f0oOZvxhD25LMWDrzcAKoJErbrvD9z2DwOYG+v58I+3dkT6YMoIogj3HuEYR65OTTiiBj6Gax4qOkLfx0ReB8wyfZkyUDqCLIY5z1emvqm4Ku5dOKIFP46yTrkkCB4M3lXauzJ0cGUEVQIMxYuzvovNiFKSbchrqPKmEMtCvbTfttduVIM0k/DUSkn4hMFZGlIrJERG62+7uKyBQRWWUfu6RPXCVdtM+QPT2f0IAyJYyJr2dbgoyQyrSwEfipMWYYcDJwo4gMA24FPjDGDAE+sM+VLHHLeUN5+XunBPUd2qksyGykRMafYkI1geJkwOnQxo4l2Let5TOFfVth7pNQtRnqDqRfviRIWhEYY7YZYz632/uBZUAfYDww2R42Gbg4VSGV5LnxrMEcf1hXv689WHmIlPi0VFVWVtfz8rzNGGNUeeQz3b9k2Q13LocHj4C5T7Ts9e/cBm/8CP50FEy+KDMytpC02AdEZABwHDAL6GWM2WZf2g70ivKaG4AbAPr3758OMZQYvPy9U3ll/hYMuLa8pltpMnDHK4sZdmhHJpzQj90H6+nStiRow/1gXSMjfjUFgJ+++AXfOWMQt51/ZLZEVjJJaQer4P3Mv1vni1+G/dvh+GugU5/Yr92zDpa+Ejjf+rnV13Vg9Ne0ApLqzEVE2gMfAb8xxvxXRCqNMZ0d1/caY2LuE5SXl5u5c+emJIeipJvK6nr/w93HBcf25s2F1jzHmQ5jwK1vhr0+mXQZSg7w4DDYtyW8v++J8K0p4f0+pv4OProvvP/MW610FkkgIvOMMeVJvdhBSq4jIlIMvAw8a4z5r929Q0R629d7A/mbsk/JaySCccinBAA+WbWrNcVR3EIkJQBWicv/fRc2z4t8ff6/IvfHy3nUCqTiNSTA48AyY8yDjkuvARPt9kTg1eTFU5QsEmeT4J7Xl3DHK4v9q4ErT+rP6z84zX9d9wnylKtein7ti+fhsbMjX3PWPrirEn5u1zmoiVI/uRVJZUUwCvgmcLaILLD/nQ/cB5wjIquAsfa5ouQczjTeR/cJ1Ece2ssqlrNq5wH+NXODv39HVS3H9O3EN0629rwG3vYWtQ3BgXxKHjDknPhjQlk1BWb+w0qFfXeVtdncpjMUtbHKYWaZVLyGPjHGiDHmWGPMCPvfW8aY3caYMcaYIcaYscaY7N+loiRB25IiLjnO2vxbuf0Ai+4+l5H9O/PIN4+nY1m4n8XdXzkKgOq6wMN/+D3vtY6wSnYYcVVi4974sXWs2Rvcf/MCOPuO9MqUBBpeqigx+N1Xj+G7Zx7Ouz8+gw5lxfz3+6MY2L0dM24b4x/z2a1ns/Duc+nX1Sp08u0zBvmv1TU2M2/DHhqamsPeW8kDxt5tHUdeDROeD742+1Gr6H3lJujQO/LrOxwCxWWZlDAhUvYaSgfqNaTkIz/9zxe8/PlmAEYP7cFT156YZYmUtHFwt7Vp3PtY2LUKOvcH0wy/ibPxe9270P/ktInhCq8hRVGi41MCANNWVLBxd7X/3A0TMCUF2nWzlABA9yFQVArFbcBbGvt1aVQC6UQVgaJkiOm3nBV0/v3nLLfCsQ9+xLcmWytgVQh5xsX/iH7tvN+1nhwtRE1DipJhjDEMvO0tAC4d2de/Ujh9SHcWb6ni8zvO8ec1UnKcAxXwwGCrPepH8OlDVvuuykA62zSipiFFyRGcD3mnuejjVbvYW93ANU/OScvn7DlYz4bdB9PyXkqStO9huYfevgPOuSfQ73JFr4pAUbLMRysr+MFzn6f8PiN/PYUz759Go8NDqbq+ker6Rjbvraa+UT2XWg2fJ9CNc+CSSdmVJQE0Kb2itAJrfns+k6av5ffvLGf6LWfRv1tbGpuaeeqz9dz75jLeWLiN3p2WcvsFw1L+rE17axjYvR0AJ/32A/bXNvqvaf6jVqbHl6x/LkcVgaK0Al6P8L3Rh/OdMwb5a0EUeT18/YR+3PvmMgAe/Xgdj368Luh1d100jNFDe/of7NFobg7s9a3fddA/3qkEwNqv0P0IJRQ1DSlKKxJaEKhDWTFrfnt+1PH3vL6Usx6YRlVNA7UNTUxfWcG+2gb+N38zl/zjU2au3c2stbupd5iDVuzYD8CskPKk3duXUnGgLo13o+QLuiJQlCzj9Qgf3TKaM++fFnXMt5+ey+x14dlaJkyaGda3bNs+Fm6u5Ov2tb9deRxfPro3HkFXA0pEVBEoigs4rFs7Hru6nEVbqvjxOZZNuck299z0/HzeXLQt1suDeHXBVl5dsNV/fvKgbkFFdBQlFDUNKYpLGDusl18JgLVS8HqEB78+3N/3yDeO97cfn1jO6KE9mPTN4/nmyYfxyc+DA9h8dG8fJ9pVKXg0oExRcgxfqor+3dqGXRvzx2msqQjEEnzw0zM5vEf7VpNNaV3SFVCmpiFFyTEiKQAfT117Iqf/YSrz7ziHLu1KWlEqJZdRRaAoeUS/rm01VkBpMbpHoCiKUuCoIlAURSlwMqYIRGSciKwQkdUicmumPkdRFEVJjYwoAhHxAn8HvgwMA64QkdSTqCiKoihpJ1MrghOB1caYtcaYeuAFYHyGPktRFEVJgUwpgj7AJsf5ZrvPj4jcICJzRWRuRUVFhsRQFEVR4pG1zWJjzCRjTLkxprxHjx7ZEkNRFKXgyZQi2AL0c5z3tfsURVEUl5GRFBMiUgSsBMZgKYA5wJXGmCVRxlcAG5L8uO7AriRfmw/o/Rfu/RfyvYPef3egnTEmZZNKRiKLjTGNIvID4F3ACzwRTQnY45O+ERGZm45cG7mK3n/h3n8h3zvo/dv3PyAd75WxFBPGmLeAtzL1/oqiKEp60MhiRVGUAicfFMGkbAuQZfT+C5dCvnfQ+0/b/buiHoGiKIqSPfJhRaAoiqKkgCoCRVGUAienFUG+ZjgVkSdEZKeILHb0dRWRKSKyyj52sftFRP5ifwcLRWSk4zUT7fGrRGRiNu6lpYhIPxGZKiJLRWSJiNxs9xfK/ZeJyGwR+cK+/3vs/oEiMsu+z3+LSIndX2qfr7avD3C81212/woROS87d9RyRMQrIvNF5A37vJDufb2ILBKRBSIy1+7L/G/fGJOT/7DiE9YAg4AS4AtgWLblStO9nQGMBBY7+v4A3Gq3bwV+b7fPB94GBDgZmGX3dwXW2scudrtLtu8tgXvvDYy02x2wAhOHFdD9C9DebhcDs+z7+g8wwe5/BPie3f4+8IjdngD8224Ps/8mSoGB9t+KN9v3l+B38BPgOeAN+7yQ7n090D2kL+O//VxeEeRthlNjzHRgT0j3eGCy3Z4MXOzof9pYzAQ6i0hv4DxgijFmjzFmLzAFGJd56VPDGLPNGPO53d4PLMNKWFgo92+MMQfs02L7nwHOBl6y+0Pv3/e9vASMERGx+18wxtQZY9YBq7H+ZlyNiPQFLgAes8+FArn3GGT8t5/LiiBuhtM8o5cxZpvd3g70stvRvoec/37spf5xWLPigrl/2zSyANiJ9Ue8Bqg0xjTaQ5z34r9P+3oV0I3cvf+HgJ8BzfZ5Nwrn3sFS+u+JyDwRucHuy/hvX4vX5yDGGCMiee33KyLtgZeBHxlj9lkTPYt8v39jTBMwQkQ6A/8DjsiySK2CiFwI7DTGzBOR0dmWJ0ucZozZIiI9gSkistx5MVO//VxeERRahtMd9rIP+7jT7o/2PeTs9yMixVhK4FljzH/t7oK5fx/GmEpgKnAK1rLfN3Fz3ov/Pu3rnYDd5Ob9jwK+IiLrsUy9ZwN/pjDuHQBjzBb7uBNrEnAirfDbz2VFMAcYYnsUlGBtFr2WZZkyyWuAb/d/IvCqo/9q24PgZKDKXka+C5wrIl1sL4Nz7T5XY9t4HweWGWMedFwqlPvvYa8EEJE2wDlY+yRTgcvsYaH37/teLgM+NNaO4WvABNuzZiAwBJjdOneRHMaY24wxfY2VSG0C1r1cRQHcO4CItBORDr421m92Ma3x28/2Lnkq/7B2zVdi2VBvz7Y8abyv54FtQAOWfe96LNvnB8Aq4H2gqz1WsOpDrwEWAeWO97kOa6NsNXBttu8rwXs/DctOuhBYYP87v4Du/1hgvn3/i4E77f5BWA+z1cCLQKndX2afr7avD3K81+3297IC+HK2762F38NoAl5DBXHv9n1+Yf9b4numtcZvX1NMKIqiFDi5bBpSFEVR0oAqAkVRlAJHFYGiKEqBo4pAURSlwFFFoCiKUuCoIlAURSlwVBEoiqIUOP8PR8i5HZKrjOsAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAD4CAYAAADhNOGaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nO2dd5gV1dnAf+/2ZemwIL0LYkFxVVCsiKJoMIlfRBNbbEk0xRiNxhKNmqAmxhgTDUYNxhZb1AgWVBQrukiR3ntbWJa2y9bz/TFz753b+972/p5nnznnzJmZ9yzLvHPOeYsYY1AURVFyl7xUC6AoiqKkFlUEiqIoOY4qAkVRlBxHFYGiKEqOo4pAURQlxylItQAAXbt2Nf3790+1GIqiKBnFnDlzdhhjyuO9T1oogv79+1NZWZlqMRRFUTIKEVmXiPvo0pCiKEqOo4pAURQlx1FFoCiKkuOoIlAURclxVBEoiqLkOKoIFEVRchxVBIqiKDmOKgJFUTKDpgaY+wxo6PyEkxYOZYqiKGGZcTvMfgwKSuDw81MtTVahMwJFUTKD2Y9ZxzWzUitHFqKKQFGUzOLrqamWIOtQRaAoipLjqCJQFEXJcVQRKIqi5DiqCBRFySw69k21BFmHKgJFUTKLsrjzsCg+qCJQFCX9aar3lPfvSJ0cWYoqAkVR0p/6fZ5yzTqoXp06WbIQVQSKoqQ/LU3e9YePSo0cWYoqAkVR0h9fRaAkFFUEiqKkPy5F0PvY1MqRpagiUBQl/XEpgsJST9u2RamRJQsJqwhE5EkR2S4iCwOcu0FEjIh0tesiIg+LyEoRWSAiI5MhtKIoOcaqD6zj5rmetkePT40sWUgkM4J/AeN9G0WkD3AGsN7RfBYwxP65Gng0fhEVRcl5Vn9oHev3pFSMbCWsIjDGzAKqA5z6M3AT4MwSMRF42lh8AXQUkR4JkVRRlNyl+2HWscuQ1MqRpcS0RyAiE4FNxpj5Pqd6ARsc9Y12W6B7XC0ilSJSWVVVFYsYiqLkCt0OsY5HfT+1cmQpUSsCEWkD/Aa4I54HG2OmGGMqjDEV5eXqMq4oSgiaG63jrrUpFSNbiWVGMAgYAMwXkbVAb+BrETkI2AT0cfTtbbcpiqLETnODdSwo8WlvbH1ZspCoFYEx5htjTDdjTH9jTH+s5Z+RxpitwBvAJbb10ChgtzFmS2JFVhQl53Apgvwi7/bGutaXJQuJxHz0eeBzYKiIbBSRK0J0nw6sBlYCjwM/SYiUiqLkNi5FID6vLFUECaEgXAdjzIVhzvd3lA1wbfxiKYqS8yx/F968Hn46x6MI+tiexSUd4UANNOwDuqdMxGxBPYsVRUlP3r0N9myEZ74LTQestiFnwHWVcO5DVv2v6rOaCFQRKIqSnhTY+wHrPrHyEUge5BVA1yFQWJZa2bIMVQSKoqQnzv2Ahv2WxZCIVXfGHFLiRhWBoijpyRaHv+r+HVBQ7Knnhd3eVKJAFYGiKOnPlnlQt8tTV0WQUFQRKIqSnhS185R3LPc+l5ffurJkOapWFUVJTxr2esoFpd77AqoIEooqAkVR0o/9O73rxW2h19Geui4NJRRdGlIUJf14yicFSv0+KHKYjDotirYthjs7WMfaatjwZevImEWoWlUUJf3w3RNoqoPCNp66M5n94tet4wf3WNftXAF37k6+jFmEKgJFUdKLYBFFncrB2Sfffo0tm+Zpa2nWfYQo0KUhRVHSh5ZmuLurp37QEZ7ylgWBr8kr9G/T5aGoUEWgKEr64ExOD5ZHsQvnvkDPo6CorVUOtHHcpFFJo0EVgaIo6UvPIz3lkvaesgic+EurvOQN/+uaGpIrV5ahikBRlPTBFUsI4PYdMOIiT/2CZ3z62q+vDbP979NYm3jZshhVBIqipBEORZBfCG06eeqdB/p0DbEZ/PLliRUry1FFoChK+uJMTem7F1C/FyUxqCJQFCV9cCagAW+LoHwf66D5L7SOTDlAJDmLnxSR7SKy0NH2gIgsFZEFIvJfEenoOHeLiKwUkWUicmayBFcUJQOprbYcvxoPBD7/1FnWsdtw62haPOd8zUR9FYMvLc2xyZiDRDIj+Bfg4+/NDOAwY8wRwHLgFgARGQ5MAg61r/m7SKiFPEVRcorZ/4BZD8A3L/mfa3Z4C4/6sXV0ehD7OoiFcxh75crYZMxBwioCY8wsoNqn7V1jjOtf6Augt12eCLxgjKk3xqwBVgLHJlBeRVEymX3brGNzvf85p+dwu4OsY/dDPW1OiyKAxjC+AotejV6+HCURewQ/BN6yy72ADY5zG+02P0TkahGpFJHKqqqqBIihKEr6Y+yj+J/atca/LdRXf4fewc8pURGXIhCRW4Em4NlorzXGTDHGVBhjKsrLy+MRQ1GUTGHVB9bR9+u+qQFeuMi/fyhKOoY+3+PI0OcVNzEHnRORy4BzgLHGGJea3wT0cXTrbbcpiqJAzXq74KMINn7lKR/+vQhvZjzF/CJo9vEmrlBfgkiJaUYgIuOBm4BvGWOcLnxvAJNEpFhEBgBDAI3+pCiKD8a76sw+9p0p3ueueA++97T/LUo7e8qdBvifd1oNrZgBlU9GL2aOEIn56PPA58BQEdkoIlcAjwDtgBkiMk9EHgMwxiwCXgQWA28D1xpj1IZLURRvfGMBNTnMSX2XjfocA8Mn+t/jrPs85W8/5n/epQi2LoRnz4c3r49N1hwg7NKQMebCAM1PhOh/L3BvPEIpipLlNPn4Ebicw6JJQekMQtdrpKd8/SL486Ee09Mt82OTMYfQxDSKorQO79zqKTf5mI+6zEpvXBXdPa/9EorbWeWL/ws7V3k2kVvs5DV7t3j6G+M/41BUESiK0kp8/oin7Dsj2PqNdSwNYwnkS/lQT3nQadaPy2vZNSP44G5Pn7pd0Maxt6AAGmtIUZRU4Dsj2JNA40JX6IlAISbuD7CprKgiUBQlBfjOCBKJK09BSxO0tITuqwCqCBRFSQUrZ3jKxgTvFwsigFjKxhmrSAmKKgJFUZLP7o3e9Zr1sHEO3NkBvnw8CQ808Olf4O/HeTcHMkNVVBEoitIKzPqjf9sWO1H9Wzcm77nVqz3l9r3hwJ7kPSuDUUWgKEryCWSy6bt+P/KS5MrQvicc2J3cZ2QoqggURUk+JsCm7YYvvOt9RiXv+XmF0LGvKoIgqCJQFCW5tLTAnH/5ty98xbseLtFMPHQZbHkiqyIIiCoCRVGSy+xHveuTngvcr6xr8mQYeLIdobQxec/IYFQRKIqSXL76p3e9XQ//PgePh4GnJU+Gk26y4hhpDMyAqCJQFCXJODaKx0+2vsx9OfVWyEvi6yi/0HI0U7+CgKgiUBQluRxyrqc86seBFYErLESiONvHXDW/0JoRqCIIiCoCRVGSi+9yTKCXfjThpyOhoMT//nkFgeMPKaoIFEVJIk318NlfvdsCzQgkwa8iX3PVvALbKslo/KEAqCJQFCV5zAtgIRRIEZR2SuxzfaObinjMU3XD2I9IUlU+KSLbRWSho62ziMwQkRX2sZPdLiLysIisFJEFIjIy+J0VRcl6Gmv923yXhq6bk/gcASMmwdAJ3m1iKwLdJ/AjkhnBv4DxPm03A+8bY4YA79t1gLOwEtYPAa4GfAyIFUXJKZx2+1e8Zx19ZwQdeif+uSXt4UKf2YhrH0IVgR9hFYExZhZQ7dM8EZhql6cC5znanzYWXwAdRSSA0bCiKDmBUxH0OcY6+iqCRFsMBcOtCHRpyJdYt+q7G2NciUC3At3tci9gg6PfRrvNkTRUUZScoK4GZt5jlZ1WQb6hJJIZWuKaWVBW7v0cVQR+xG2zZYwxIhJ1ZgkRuRpr+Yi+ffvGK4aiKOmGM/3k4f/nKTsjkR59eXJl6DHC8VxH5jLFi1ithra5lnzs43a7fRPQx9Gvt93mhzFmijGmwhhTUV5eHqMYiqKkLc5ZwPjJgfuc+1DryAIeC6a5/269Z2YIsSqCN4BL7fKlwOuO9kts66FRwG7HEpKiKLnEnKmeclFZ6uRwsdd+Fe1ak1o50pBIzEefBz4HhorIRhG5ApgMjBORFcDpdh1gOrAaWAk8DvwkKVIripL+9DzSU/bdED7vUWv9vjUZPNY6dtClaF/C7hEYYy4McmpsgL4GuDZeoRRFyQJCeQsfeVHryeHi2Kth7jPQ/dDWf3aao57FiqIknuo18MoVqZbCG5fZanNDauVIQ1QRKIqSeB52LAt9e0rq5HDiUgRqNeSHKgJFUZLLYL9V5NTgsmLSGYEfqggURUksvg5bgYLMpQL30pCmq/QlwUHAFUXJeRr2e9fTRhHYlkuLX4Pq1VZ97B2plSlNUEWgKEpiWDodeh4FX/7Dqh8xCfqPgcKS0Ne1Fi5FsPpD6wdUEdioIlAUJX7q98ILPpbmezfDyItTI08g8lopuF0GkhV7BFt219HSEnW4I0VREsXWhf5tHfu1vhyhCLRE1awWRJAFimD9zlpG/+ED/v7hylSLoijpz8r3YN1nib9v227+bem27BIoyqlaEAFZoAg2764DYNaKHSmWRFEygGe+C0+dFdu1zY2weV7gc8ZnRl7SMbBySCUiMPw877bm+sB9c4yMVwQuvlxTzdsLt6ZaDEXJXmY9AFNODrwM5JssPl2dtnyXh5p0RgBZoAg27apzlx+ZuSKFkihKlrPxK+u4Z7P/OT9FkKbJX7550buuMwIgCxTBDS/Nd5d37lPtrihJY9UH1jHQurrxefGffX/y5UkE6lwGZIEicLJl94FUi6Ao2c+BGv82Pyey4taRJV6adEYAWaYIAGob0nRtUlFSzbrPo79m5XtwZwd442eetv1V3n02z4UnxlnlEbYvQe+K2GRsbXRpCMhCRfCJWg8pSmA+ezi6/rXVlpURwNeObGOb53lbCS181VM+/P/gjl3QZVDsciaTM//gXdfNYiALFMF5R/b0qrcYePrztVz1dCXNLYY7Xl/Ihura1AinKOlEwz5P+a2bw2/ofviHwO2LX4PKJz11p4IpLIW8NH6tdPJxctu3LTVypBlp/C8WGa/N87ZgKC7M447XFzFj8TaWb9vL05+v47uPJsGBRlEyjTWO1JCzH4VNX4fuH8g6yMXmuYHbC0ujl6s1afD5KHwxjUJgpJC4FIGIXC8ii0RkoYg8LyIlIjJARGaLyEoR+Y+ItGrowednr3eXP1+1E4Dte9N7HbClxbD3gFovKK3Muk9Dn69ZF/xcWVfrWLfLuz1dIo0GI5B/Q816/7YcI2ZFICK9gJ8BFcaYw4B8YBJwH/BnY8xgYBeQtHx19U3+U9t3F3umepXrqpP16ITy0HvLOfzOd9ldq8pAaUXe+23o81u/8a6feitcaZuQuqyCdvkoCwkQxiGdyAsQZ/Pd2+K7544VsG97fPdIMfEuDRUApSJSALQBtgCnAS/b56cC5wW5Nm7qmzxOLD8bO8Tv/PRvLE/jTm3SO+rgS3M2ArC3XhWBkkTa94rtusPOt44N+6D30VZ57SfWsdF26Bw6AU67DboNi0/GZCPi37Z+dnz3fKQCHjo8vnukmJgVgTFmE/BHYD2WAtgNzAFqjDGu+ddGIMa/vvB8ttJjITTpmD5B++2qbWTmsvTV2C7/h40OL2lFSTiBNoeDbRjXOmbTA0+2jsXtPW3rPrFs8F3+A2N+ASfdmBg5k0mgpat9CQhN05TZPkzxLA11AiYCA4CeQBkwPorrrxaRShGprKqqCn9BAOZv3O0ulxWFTq1w+VNf8cd3lsX0nNbio+Wx/R4UJSJamqDfGO+2J8cH3jSe+4ynPHwinPIbOO5H3n0+ug8abUVQVJZYWZPFsAmpliAtiWdp6HRgjTGmyhjTCLwKnAB0tJeKAHoDmwJdbIyZYoypMMZUlJeXxyTAIT2sL5RfnD6EgvwAUz4fXvhqQ0zPSTau2Wp52wzxxlQyk5YmKGnv3bbxS3j8VP++myrtgkBJBzjl11Dc1qfPHM+MoLBNwsVNCoFCUUNy/QmW/C/tPZjjUQTrgVEi0kZEBBgLLAZmAvaiIpcCr8cnYnDaFlv/qKcO7RaRIjhlaGwKJ9l0KbOmq797c3GKJVGylj1brNAQwV6EvvQdbR1vXOV/7ujLrGPtTo8iKGrr3y/dufA/8d/DN/y2L6s/gv/8AD64O/5nJZF49ghmY20Kfw18Y99rCvBr4JcishLoAjyRADkDUt9obRYXF+ZRXBD+D9w1g0g39tRpWAwlyaycYR3r90bW32UWWtrR/9wZ91jHIWfArrVWuShDZgROeh7lqMSY4TDcl77LmiiUT0YaEFfOYmPMbwFfG7TVwLHx3DdSenYs5XsVvencxvqi7tWxlE01wTdcCyOYNaSChuaW8J0UJR5K7Bd6sCWQ5ibId7wO6mqsJaFAM4jidtbx4z952grS3JEsEM6xhfuyD0a4TWKX53Ka50vOaM/iEX06cv/5I+jWvgSAd64/KeRX/4HG9IyR3rVtmjvhKJmP66W3/jOY8CBMes77/B8He9cP2Iog4vtn0KvknIfghF+AOGWOURE0hglf8+6t1jFdE/XYxDUjSDfaFhdQFOKrf++B9PvH2FBdyw47j8LArhlieaFkHp0dQeCOuQK2zPc+7+shfGC3ZxaRbVRcbh0PeKwOY54RPPt/nvKBPf6b8S7SPPRGBqnxyHCalDrpXFZETRp67k77Zou7HOOfoqKEp9swa3P0VyuteqPPksaQM73rdTWB9weyiUBextGwZwtsc6TtnNwHqpbDvgBm4B16x/esJJN1iiAY1fsb+PcXIWKnpIh56wMk+VCUZDB0PLS1Lec69fe0d+jjvwx0YHfopaE7d8MP37HKLgujTMMrHEYMn2GB9geWTbeW2ZZO825P8xhMOaMIXFSuTa/4Q28vsrwaj+nfCRPr9FRRoqVdd7j8LbhmFuze4J3Ld86/oGpJ+D2CvqPgB6/ARS+G7peuxLtZLAFen674Tas/8rYoytfN4pQzbnh3d/n8x2LI0pREzrBl69kxvdcQlSyk3/HQY4T37OCrJ+B/P7fKkewRDD49+Lp4uhPvjCDUBrAIvPVrT32vTxiLuvRaCch6RfDYD0by+CUVnBqBM1n1/oZWtywqLMhjYLm1SazzASUlHP49QKClBab90tPemOWxr5yWTtFED21qgHWfhUl8LzD/BU/180c85cVvwH39vPNDpJisUwQuL10XB3WwvrRnLgsfx2fk3TOYNOWLpMgVjAMNzbQpyic9PRyUnKC0I2D8k9JvW5QScVLCkjci7/vubfDUWbBlXvA+gaKcunjpUuu4vnXfNaHIOkUwvKf3NLV9iWUZMP7Qg9xtLS2Gu/63iJXb9+HLvA3+U7bmluR9q9c1NlNaaE1RdYtASQmuSKOLXvVun/iIf99sJRqHL5cC2BMwjJqNQOeBgU8dZueBbtcj8mcmmaxTBK6XaX6epZEHllsxUO6aeKi7z2erdvLUp2u59tkwqfqAVVX7GPSb6Zz8wEwefHcZ1fsTG5yqtqGZksJ8JNQXhKIkkx3LreNHD3jaRlwEXf1zfGQtgTZ+g+FaEtq/M8T9BLYHmVG5LIhM+ji4Zp8isFfa/3lJBXNvH+du7257HwNsqvH3BgxmsbNwk+WXsG5nLQ9/sJJb//tNwH6xcsA5I9BdAiUVVPzQOjrj8g8KEJE0q4ni/55LEbhe5O16+vep2wV9jw+94R5yj6F1yTpF4MpL0KYon04++wUPfm8EAL9+xXqZL9vmCcAVLN7Pz1/wXgeMxSntP1+t52U7C5kvdY3NlOoegZJK+vvkKChsA0d8LzWypIpo1mW32R+DWxZYx5Nv8u8z71kwLdDjiODPSqPQ1FkVYgLgvu8ewYg+6zl2QGe/c64v70C4wjyEozGGAHEuxXP+0f7ehXUN1oygoalF9wiU1ODrYZvueYdTxaY5UOp4r6z/zDoe9h044gL4+I/egfjq90CZY5+gpcWyVGq23zXNScyBECVZNyPoVFbEtacODrjm7tvUodTaIDLGcMLkD9ztew4E/+oPFd00FuoarT0CnRIoKUMEjvyBp35p0lKIpDERfIU9fho8fKR/e0GpFYZ77B2WxzVA98Pt2EMOpzzXUpIrUJ0qgtTgqxxa7E/wJh+roKVbgsds9+0bDZ+s2MH2vR639BmLt7H3QBOlRfoFpqQYZ6pJZ4C6bKdDX+sYLihcqDwOvl7DvY+Fsi7WjKC4PfQcabW79gQO7LGOaz+JXt4kkVOKoJeP926/LlYyjW17vGOGTHcEgispzKNdsWfqXB+Hw9kPnpjN9x77nC2767j2ua+56mkrHWAbNR9VUo07NSXRhZ/OdL79qHVs3yt0v+1Lg5/zXWooKLaC+tXvtbyuD/uO1e7yRG6yVxXWfhy9vEkipxTBYb06uP0KANoUWuUx98306jeo3PN1VJifxxF9PP8x9sQZynrtzlpG/+EDpi3wKJvCgjxE14aUVLJpjnWU/NDOUNmGK8lOS5gPPBPF3mB+EdRVA8aaEbh8FFyKII2shVzklCIA+PLW093lYJZCeXnCwk27WbCxhr0HmujWriRgv0Tx36+DO6Y8O3sdU2ZZeWM31dQFdIJTlLgpsl+IaWTb3iq4NsbDjTua30tevsc3o6jMo1j32h9/LoXQsV/k90wycSkCEekoIi+LyFIRWSIio0Wks4jMEJEV9rFTooRNBCWF+Sz53XjGDO7qZwF00sFWPKL/fLWBc/76Cd965FMACvKS+4W0r74p6EfYrf9dyO+nL6WpuYVxD37E6Q9+lFRZlBzlinet47f/kVo5WhtXBNJwM4JoHM5WvOspFxR79gIePd46umYENetgxXuR3zeJxDsj+AvwtjFmGDACWALcDLxvjBkCvG/X04rSonzaFhfQ1Oy9KL98q7UhtMAnuY3v/vCeA400RWhGGsrc1LVn8fp1JwD+Tm21DZ5lqF+9NJ/ahhz7WlNaj+7DLYuXEZNSLUnr4nrBh1v6iXUDz7R4h7veswV2rvDUn/1ubPdNMDErAhHpAJwEPAFgjGkwxtQAE4GpdrepwHnxCpkMCgvyaGxuYXedZ73uyhMHBOxbWuT9azrizne56eUFET3nhS/XBz13x7nDWTt5Al3bFgfcIdhc49nEfm3e5oiepyhKFLiXhsIoguYgzl8T/x76urwC7yWgT/8SuWytSDwzggFAFfCUiMwVkX+KSBnQ3Rjj2gndCnQPeocUUpgn1De1MHe9J1frD08IrAiGdm/H2skTvNpenRsq4JSHvfXWV/3xg7r4Obm1LfZ25PH95ggW1yiZQfAUJadwhaIOtzTU5PN/8eRfw3efgKO+H/q6zXO9l5VmPxq9jK1APIqgABgJPGqMOQrYj88ykLHWOgK+tUTkahGpFJHKqqrwIaITTUG+0GKMOzhdYb6QF2Qv4PvHWRr90tHRb+706GBtNN9+znBWV+0P2i/QHsF+x9LQKY58Cm8t3OLfWVGU6Il0RtDiY+lTVg6Hnx/+/kdfFn5/oSX6aAWJJh5FsBHYaIyZbddfxlIM20SkB4B9DJjxwRgzxRhTYYypKC8PnzQm0eTn5dHUYtwOYk9edkzQvi4FkZ8X/a/Lta7fuayIHfu8p5e+X/a+y5ALNnj2Kj505FP4w/SlfOfvn/JMGuZgVpSMwr1HEGZG4GvyGWni+26HhFcE6z6N7F5JJGZFYIzZCmwQkaF201hgMfAGYGde4FIgLf3VC/KE5hZDfaOljTuX+SeXfvySCqb+8Fh3fe1O7y96X0e0QNTZiqAkQJyjoQe1c5cD+RH8+b3lAe+5qaaOr9fXcNtrC8M+X1GUEERqNeSbljLUy/0yn8T1eQEiBzjTg9aGCGfdSsRrNfRT4FkRWQAcCfwemAyME5EVwOl2Pe3IzxOamluobwr+oh43vDsnH+yZrXy8wnsJq2pv+OiBrtSXbYryOaa/x5J27eQJXqGxAbbuOcDFT8xmyZY9kQ9EUZTYidSPwFdRhFpK6nqw970DKY0r3/eUuwwO/exWIC5FYIyZZy/vHGGMOc8Ys8sYs9MYM9YYM8QYc7oxpjpRwiaSwnyhqcVQ32T9gxYXhP9V+H61RxKJtLahmYI8oTA/j39eGnz5ybVH8PGKHVw5tTJoP0VREojraz2ceeg2nzwkoRLXu2IPFVlJsRh8un+fsq4w6Tn72ak3C885z2IX+Xl51DY0u81AiwvCB34ryPdWBHUR2PW78g2AJ9ppOHbVNrhnEoqiJBGJ0Gros79616vXhLin/S4pthVBr5Gh+4VSKq1EzioCX2/h4kLrV3HjmUMDdQfwc0Crrg0fRnb73nqK8j2/5r6d21DRz9/Z+pOVO9zl2oZm9tj+DXefd1jYZyiKEiORbBYHsuo5+cbg/Uvaw7i74dL/edr6jfHv59pwznCroYwm30cRlNgzgmBOZQADHcHoAA40hv4H/GptNdMWbGGnwx9g2s/G8MLVo/z6btzlnefAvWTlUCL3ffdwbptwiFe/FvUpUJTYiWSzOFCS+tIwkXNO+Bl0cYTznvRsgGe7ZiM6I0gZvjOCQnvZx/X17huyGvxzEbg2moPx8+fn+rW1KymkID/8r33DLit5RZFj7+KCY/py5YkDvfrd+lpicygrSk4RSYiJf5wU/3NKHbmL2x5kHffZlvXLpsd//zjJWUWQ77Pe70paIyI8c8VxvPij0X7XdG9f7FX3XSrypaYu9nCz1zxthQUuKsjjp6cNZkBXz2xkye/Gu8vPf7kh5mckkxXb9obM9KYoaUEkVkN1DnuXS9+E6xfF90zX9dts8+/ZqQ/0l7OKIFRE0TFDugacEfz1Qu9Nn3BWQ9EEiTu4e1uvuis0BcANZwxl5q9OcddLi/I5pEf7iO+dCsb9eRYXPf5FqsVQlNC4l4YiXKfvcxx08M89HjEHHQ759t6Aa9+gY9/Y75cgclYRxOIl3LmsiNsmHMLzV1lr/MHyGfgybnj4cEuvXXsC0342hikXH+3V3tAU+Bmt4WtQ29AUcZRVJy6ZF25SfwglzXHNCCqfjKy/b1rKaPjFN3D52576wWdax+Hfiv2eCSJnFYFzRrDwrjMjvu7KEwe6g8c1NllLQ/M31LDLJ0CcM6T0r8cPC3vfNkUFHNqzA21LvF3XIz2wyDoAABiySURBVPFVCMeG6lr+8dGqqK8bfsc7XPPvOVFfF4lZraKkBe6kMRFG940ne1vHvh6TUte9jrkSehwZ+z0TRIQBM7IPp9WQbxTQSK7NE89LeuLfPuXg7m159/qT3X3qHV/yg7u19btHMHw9nM8+vEfAfucf3ZuX52yM6J4n3m+l4qzo35mjA5iuhuL9pQFDRYVkX0PqrSAUJSJSnZZzwp9S+3ybnJ0R7LfX4McM7hrT9YX5Vj6D+RtqAFi+zTuF5P762F6GTg/nW88+hLIolVQogoW1DkSwJalgvL1wK//8eDUAtTGOXVHSjmbH3/Koa1MnR5LJWUVQZ3vujozyC9lFfVMLK7fvY+LfPJED56zzWBfs2Bf5S9eJ08P5qpMGBu13wxlWPJM2ReE9ol0s37Y34r5bd4cPqOfkR8/M4Z5pS2huMex3LA3tjsNySlFSjtPGf/zvUydHkslZReAinomh77LJdx/93L0+vq8+thega0YQ7gXfo0Mpl47u5+VnEI5HP4x8n+CkB2a6y66X+f76poChL16f53G4mbt+l9eMYMRd7/r1V5SMIQ2cvVqDnFcEieaeaYsBj+loJBvFTlzxjCLZtyjMz6MxgiWcg+wop98fFZuZ2l/ft3KsjrjrXYbd/jb1Tc00NLXwxeqdtLQYfv7CPHff3XWNfLV2l9f1f54ROJy2oqQ9WyNLSZvpqCJIMBvsUBEuRXDikOj2IErtzeJhEfgJWHmXPdZJ1fsb/PYmXvxqA1vtvAnNYRzggrGu2vJydnlWD73tbR6ZuZJJU77gA59Z0RVTK/3yKPzl/RUoSkYyM3uXg5zkvCJIdKQeYwzGGLedfzRr+AAd2xTx/FWjeOSio8L2LczPo6G5xW2qOvLuGZzyxw+9+tz0iueLJpyn8+aaOnbsq/db/jl1aDe/bGr/nWtZLK2q8t4kV5SMZeq5qZYgZeSsIgiUESwaurUrDtjetriAqZ+t5aH3rK/gNkXRW/2MHtSF9iXhHVeK7GUkZwwkZ7Kctxdu9er/8pyN7A0S9uH9Jds4fvIHVNzzHne8brm+uxzhvtm0m30+M40N1dbM58XK4CEuzh3R013+cFn0ZqiK0qqsmeXf5opBFCh6aBaRs4ogXi4Jksh+QNcyKtd51sjbFEc3I4gGV/C6YBY+gXIa/+GtpQH7OmMWvVhpfe2fc0QP+9z6oOawq6r2B2zPzxP+euFRjD/UCrB12VNfBeynKGmNyzE01f4GSSZnFUG8/66FQSKI1jU2ey03tUugH4Ava3dYL+GfPPt1wPPOHAcunpu93q9tQ3VtwPzLXdt6Zj2fr7Lyqgbzu3j92hOY/rMTAejTuZT5vz0DgC2O+2rsISXjWP+ZdcxyRRD3W0pE8oFKYJMx5hwRGQC8AHQB5gAXG2NiM6pPIiP7drKPHcP0DIxTEfzm7GEU5edx5/8W89Sna736SRL/gFy33hKlzb8vLs/jUNzw0nwArhgzIKCCGdHH+j2unTzBq93lcAfw2SrLyigvRMA/RUlLhp6dagmSSiJmBD8Hljjq9wF/NsYMBnYBVyTgGQlnzJCuzL19HKcM7RbT9YWOMNaDytty2QnBE9oki9JCS4/XBQjpMHf9Lr+2aHGG3R49sAsA7RyxkI7t3znsPXytpgIpEUVJe464INUSJJW4FIGI9AYmAP+06wKcBrxsd5kKnBfPM5JJp7KimK91fuknIjBcPOwPEORtzwGPcnjt2hNYfs9ZDCovo1+XNl79goWSOKRHewZ3a8fXt48D4PPV1tJQe0fe5dGDunD24Qfx23OHB5XtkQtH8uI1ntwOlzz5ZQQjUpRWZOLfw/eR7F5Fj3d0DwE3Aa63SRegxhjjegttBHoFulBErhaRShGprKqqilOM1se5D1Af5GUa6gWZCFwKyDftJkCZbbb6t4tGcmSfjhQV5LGrtpF1O2u9+gWLFPrWz631fl/Htg6lhfzstMGAZSr79+8fzeUhZkMd2hRy7IDOLIoiwquitCpF3iloqQlgCZeX3fE5Y1YEInIOsN0YE32cYsAYM8UYU2GMqSgvL49VjLTA+ZXsJNQLMpE0txivMNgrt+9jrz0jKHeYuQYKOuebU2HYQe344pax7rpvCIv2JYUc2qsDQFTJcZzB8179OrKoqYrSKjhzDPztOHjoMPjmZe8+BYHNxbOFeGYEJwDfEpG1WJvDpwF/ATqKiOt/fW8gQObn7KFr2yJOOdhSZH+Z1LpxxUcP6uIuH3X3DHf59Ac/4vJ/WeaaJYX+/8Qbqj2zAqciGDO4K2//4iQO6lAS9JklhXmcfkh33vzpGMYfdlBU8t545lAAfvnifK98DYqSUpxf+1W2efUmH0u8eBLSZAAxKwJjzC3GmN7GmP7AJOADY8z3gZnA+Xa3S4HX45YyjTnj0IPc+wUTj+zF6YeEz0aWKILlKnDijGbqYnNNnbvs3CP4ySmDwt5PRMjPEw7r1SFqi6iLHb4XK7erR7KSJgRa9okhg2Emk4zR/hr4pYisxNozeCIJz0g5wV6BI/vFZo6aLJwzgr9dZOVcLnBYPLkUwb3fPozjY8zNEClOb+mzH/6YHfvqQ/RWlFYi0Nd+XgE0xmeWnUkkRBEYYz40xpxjl1cbY441xgw2xvyfMSan/rf/6KTwX9WtSakj1pFryadqbwMbqmtpam5xK4Ju7YIvBy353Xj+fMEInrysIm55XvqRZUHU2GyouOc9np29jv43TwuaG3lTTR39b57GF7bVkqIknLwgiqCpzr89S8mt+U8CCbbCnZcnXDK6H9eESCqTSO4//4iQ552xjlw+AD96Zg4n3j+TB95Z5t4jCJXXoLQon28f1ZvThsW/7DWgq7eFxq3/teIa3W7HN/Ll+v9YIa4nTfH2Sn529jqWbt0TtzyKEnBpSPKhKe38YJNGdttEJZHB5VYe4hG9O/id+93Ew1pNjl4dS0Oeb+PIgeyb9nLWih1uh7qiICEzEk2XIL4bCzbuDtj+5RpP1rem5hYK8vNobjFuBeLryawoUZMfSBHkQZO9NBSJn0GGozOCGBk9qAvv33Ay36vok1I58sJs2DrDOXRt6/0Srm1o4rW5llFXaznFiQhzbx/np0ALAvhCvLlgs1f93umWA/u/P1+bLPGUXCTg0lAeNNmr2lluOgo6I4iLQfasIJV8HUUoieKCfLq3L2bbHusPfN3OWreDmXMDOdl0KivyCp198sHlbNhVy99mruSBd5bxxnUnUFSQx3XPzfW67qlP19KzQ6lbIQDsPdBIuwhCditKUAJtFjc1eGYEBcH3z7IFnRFkOL4JY8LhDJbnTJpT0S983KBE4grjfdnx/WlfWsjqqv088M4yAO6dtoS562sCXudUAgAbd+XOhp6SJALtETTXwwH7b1AVgZLuTDgisC/BbRMOcTtwOfnBKI8tf9/OVtyhsqL8kJvFyeCCY/qy6K4zufNbh7J4s/f+wOw11Tz20Sp3/frTDw56n/XVtUHPKUpEBFIEdTXQYP9tlaaXSXgyUEWQ4Tg3i28Y53lhXnniQK49dbBf/2tOGsiKe88CYOnWvQD8/PQhSZYyMK7N6+17/C2MnTGRzjuqJz89zX8sALv2N7Bo82763zzNK8yGokRMIEXw9VRosUOm5ccenDJTUEWQ4TiXes4d0ZOPbzqVZ644Lmh/EaEwP4/B3Tz7GwUp9qIc1qNd0HNL7x5Pvy5l3HCG/+wG4OZXv2HCw58AcP87gbOvKUpIAu0RSL5HEWR5wDlQRZDxOCOPFhXk0adzG8YMCe8h7My57Bt4rrX53cTD6GAH7uvdydsctsRh/vq7iYdysh3X6VuOfMguogmCpyhuynyCXvYbA31H5ZQiyP4R5hDRhP654Jg+fGann7zouL5JkigyDunRnvm/PYOd++opKy5g2O1vAzBqoPcG9iWj+3PJ6P6srtpHr06lvDHf27z0zflbuGR0/9YSW8kWRODqD2HKKVY9Lx/WfATrPvXUsxydEWQBR/ez0m52ahP5WqZzOah9mphfdmlbTLFj09rXC9nFwPK2FBfkc1B7b2uOL9dWB+yvKGHJd/gKbF/sfU5nBEom8MqPj4/6mtb0G4gGEWHt5AnMXLqdUQO7hOz7xW/G0v/maa0kmZLVODeEG/Z7n8sBRaAzghzFlXM5XfPInzqsm1fAvHC4lsUmTfk8SRIpWY1zw9h381iXhpRs5ei+nenatsgdDTRTeeO6Ezi6XydG27OHL1ZXa9IbJXqcL3/fkBM6I1CylQ5tCqm8bRxHt7JHcaI5ondHXvnx8fzK4Tw34JbpKZRIyUicS0O+fgM6I1CUzGBk305eqUL3HmhMoTRKxuGcEbTx+TjSGYGiZA5OK6Pl2/amUBIl43C+7Btrg5/LUlQRKFnDkG4eD+XvPqqbxkoUOPcFqlcHP5elxKwIRKSPiMwUkcUiskhEfm63dxaRGSKywj52Spy4ihKc0qJ8Pr/ltFSLoWQi7q/+AGZ0gRLXZBnxzAiagBuMMcOBUcC1IjIcuBl43xgzBHjfritKq9CjgxWiYsLhPWhpMWzfG30C8gUba5ixeBurqvbREmWYbyVDycuDk26yPIyd9ByZCmlanZgVgTFmizHma7u8F1gC9AImAlPtblOB8+IVUlGi4fBeHahrbObVuZs49t73Wbtjf/iLHHzrkU+56ulKxv7pIx51hMMOR01tA6/M2YgxRk1YM5HTboWeR3q35UAuAkjQHoGI9AeOAmYD3Y0xW+xTW4GAGc9F5GoRqRSRyqqqqkSIoSiAlXCnpraBX700H7DyHk9+aykNTeGD681ctt2r/sA7y2hoauH21xby/JfrMcawY1+9X0Kg/fVNHPm7Gdzw0nwG3DKdyW9pJNSM5eoP4ZRbYPR18J0pqZamVZB4v1xEpC3wEXCvMeZVEakxxnR0nN9ljAm5T1BRUWEqKyvjkkNRXAQLO/G3i0YGTeQT6rqDu7dl+bZ9gJUIaNoC6ztn7eQJIa91nleUZCAic4wxFfHeJ64ZgYgUAq8AzxpjXrWbt4lID/t8D2B7sOsVpTW59rmv+f30JazfGV1WM5cSANxKAOCTFTsSJpuipJJ4rIYEeAJYYox50HHqDeBSu3wp8Hrs4ilK9BzWK3hegimzVnPqnz4MeG5gueWHcPygLqydPIEXrwkdfuOu/y3i9tcWumcDFx3Xl/9dN8Z9XvcJlEwhnhnBCcDFwGkiMs/+ORuYDIwTkRXA6XZdUVqNf1wceqbsu74PMGXWKlZX7WfssG48d9UoAIZ29/glOJWLq33F9n38+4t17vZtuw9weO8O/GCUld9hwC3TOdDYHPtAFKWViMdq6BNjjBhjjjDGHGn/TDfG7DTGjDXGDDHGnG6M0SDxSqvSs4PH0mN0mFDWLn4/3drcfX+pZyWzQ5tCvn1ULwCWb93HN3eewci+HXns4qNpX+JvW37ntw4FoLbe8/Ifcde70Q9AUVoZ9SxWsg5xpGq74Jg+ADz6/ZFMPNI7veXFT8ym/83TQi7h/OE7h/OjkwfxzvUn0a6kkFd/cgIDupbx+S1j3X0+u/k0Ftx5Bn06twHgqpMGus/VN7UwZ101jSlOB6oooYjbaigRqNWQkmjW7NhPYb7Qq2Mpy7btZdhB7Vm0ebc70X0wZv9mLN3bJ8Z2/IYX5/PK1xsBOGVoOf+6/NiE3FdRXKSF1ZCipCsDupbRu1MbRIRhB1nr+4f27BDymjGDuyZMCQBuJQDw4bIqL2uldPgAUxQXqgiUnOKQHsEtin562uCEPmvWjad61X/y3BwATn/wI66cas2AVSEo6YAqAiWnuMmRwOaWs4a5y2snT+C4CDeWI6VvlzasnTyBNX84G4CFm/Zww4vzWbl9H+8v3c7FT8xm5N0zVBkoKUcVgZJTnDqsG2snT2Dp3eO55uRBrfJM5+a1c7no4xU72FXbyGVPfZWQ51Tvb2DdzujiKikKQPbHV1WUAJQUWukHn73yOCRA5OHW5KPlVVz33Nc8clF8kS5H3j0DgJX3nkVBvvWNV9vQBFhKolu7EooK9NtP8UcVgZLTnDC4a6s8Z9Xvz2bKrNXc9/ZSZt14Kn27tKGpuYV/fbaWe6Yt4c0FW+jRYTG3Thge97M27KpzZ2s77vfvs/dAk/ucxj9SAqGKQFFagfw84cenDOKakwaSl2dNQQry87jgmD7cM20JAI9/vIbHP17jdd1vzx3OKUO7eaXhDIQzb8LaHfvd/Z1KAKzNaUn1FEhJO3SeqCitiEsJuGhXUsiq358dtP9d/1vMqX/8kN11jRxobGbW8ir2HGjkv3M38u2/f8oXq3cye/VOGhwOa8vsfM2zV+/0ulfXtsVU7atP4GiUbEFnBIqSYvLzhI9uPIWTH/gwaJ+rnq7kyzX+0VomTfnCr23Jlj0s2FjDBfa5Ry46irMO60GeoLMBJSCqCBQlDejXpYx/XlLBN5t2c/24gwFPcLyfPT+Xad9sCXW5F6/P28zr8za766MGdiE/TxWAEhxdGlKUNOH04d3dSgCsmUJ+nvDgBSPcbY/94Gh3+YlLKzhlaDlTLj6ai0f145Nfezuwuejatjh5QitZgcYaUpQMwxWqom+XNn7nxv7pQ1ZVeXwJ3r/hZAaVt2012ZTWJVGxhnRpSFEyjEAKwMW/Lj+WE++fydzbx9GprKgVpVIyGVUEipJF9OncRn0FlKjRPQJFUZQcRxWBoihKjpM0RSAi40VkmYisFJGbk/UcRVEUJT6SoghEJB/4G3AWMBy4UETiD6KiKIqiJJxkzQiOBVYaY1YbYxqAF4CJSXqWoiiKEgfJUgS9gA2O+ka7zY2IXC0ilSJSWVVVlSQxFEVRlHCkbLPYGDPFGFNhjKkoLy9PlRiKoig5T7IUwSagj6Pe225TFEVR0oykhJgQkQJgOTAWSwF8BVxkjFkUpH8VsC7Gx3UFdsR4bTag48/d8efy2EHH3xUoM8bEvaSSFM9iY0yTiFwHvAPkA08GUwJ2/5gHIiKViYi1kano+HN3/Lk8dtDx2+Pvn4h7JS3EhDFmOjA9WfdXFEVREoN6FiuKouQ42aAIpqRagBSj489dcnnsoONP2PjTIh+BoiiKkjqyYUagKIqixIEqAkVRlBwnoxVBtkY4FZEnRWS7iCx0tHUWkRkissI+drLbRUQetn8HC0RkpOOaS+3+K0Tk0lSMJVpEpI+IzBSRxSKySER+brfnyvhLRORLEZlvj/8uu32AiMy2x/kfESmy24vt+kr7fH/HvW6x25eJyJmpGVH0iEi+iMwVkTftei6Nfa2IfCMi80Sk0m5L/t++MSYjf7D8E1YBA4EiYD4wPNVyJWhsJwEjgYWOtvuBm+3yzcB9dvls4C1AgFHAbLu9M7DaPnayy51SPbYIxt4DGGmX22E5Jg7PofEL0NYuFwKz7XG9CEyy2x8DfmyXfwI8ZpcnAf+xy8Pt/xPFwAD7/0p+qscX4e/gl8BzwJt2PZfGvhbo6tOW9L/9TJ4RZG2EU2PMLKDap3kiMNUuTwXOc7Q/bSy+ADqKSA/gTGCGMabaGLMLmAGMT7708WGM2WKM+dou7wWWYAUszJXxG2PMPrtaaP8Y4DTgZbvdd/yu38vLwFgREbv9BWNMvTFmDbAS6/9MWiMivYEJwD/tupAjYw9B0v/2M1kRhI1wmmV0N8Zssctbge52OdjvIeN/P/ZU/yisr+KcGb+9NDIP2I71n3gVUGOMabK7OMfiHqd9fjfQhcwd/0PATUCLXe9C7owdLKX/rojMEZGr7bak/+1r8voMxBhjRCSr7X5FpC3wCvALY8we60PPItvHb4xpBo4UkY7Af4FhKRapVRCRc4Dtxpg5InJKquVJEWOMMZtEpBswQ0SWOk8m628/k2cEuRbhdJs97cM+brfbg/0eMvb3IyKFWErgWWPMq3ZzzozfhTGmBpgJjMaa9rs+3JxjcY/TPt8B2Elmjv8E4FsishZrqfc04C/kxtgBMMZsso/bsT4CjqUV/vYzWRF8BQyxLQqKsDaL3kixTMnkDcC1+38p8Lqj/RLbgmAUsNueRr4DnCEinWwrgzPstrTGXuN9AlhijHnQcSpXxl9uzwQQkVJgHNY+yUzgfLub7/hdv5fzgQ+MtWP4BjDJtqwZAAwBvmydUcSGMeYWY0xvYwVSm4Q1lu+TA2MHEJEyEWnnKmP9zS6kNf72U71LHs8P1q75cqw11FtTLU8Cx/U8sAVoxFrfuwJr7fN9YAXwHtDZ7itY+aFXAd8AFY77/BBro2wlcHmqxxXh2MdgrZMuAObZP2fn0PiPAOba418I3GG3D8R6ma0EXgKK7fYSu77SPj/Qca9b7d/LMuCsVI8tyt/DKXishnJi7PY459s/i1zvtNb429cQE4qiKDlOJi8NKYqiKAlAFYGiKEqOo4pAURQlx1FFoCiKkuOoIlAURclxVBEoiqLkOKoIFEVRcpz/B65tVPEpLPUpAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAD4CAYAAADhNOGaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nO2dd5hU1dnAf+/sbAOWXqUICCLYEBELFgSNxh41UeMX0ZiYL9GoX4pBjbFEE42JJTHRzxbxM5bYEhWjImLQCMgiSC9LBylL211g+57vj3tn5k6fnV7e3/PsM/ece+6dc2dn7nvPW8UYg6IoilK4uDI9AUVRFCWzqCBQFEUpcFQQKIqiFDgqCBRFUQocFQSKoigFjjvTEwDo2bOnGTx4cKanoSiKklPMnz9/pzGmV6LnyQpBMHjwYCorKzM9DUVRlJxCRDYk4zyqGlIURSlwVBAoiqIUOCoIFEVRChwVBIqiKAWOCgJFUZQCRwWBoihKgaOCQFEUpcBRQZBhWtsMf5+3idY2TQeuKEpmUEGQYZ6ctZZbXl/E87PXZ3oqiqIUKCoIMswD760A4M0FWzI8E0VRChUVBFnCos01mZ6CoigFigoCRVGUAkcFgaIoSoGjgkBRFKXAUUGQJZQV679CUZTMoHefLGFgtw6ZnoKiKAWKCoIM0uYIItu5rzGDM1EUpZBRQZBBmtvavNt7DjSzZIu6kCqKkn5UEGSQwLQS5/3p0wzNRFGUQkYFQQZpbtX8QoqiZB4VBBnEsyI4ZlDXDM9EUZRCRgVBBmmxbQQdSoq8fWonUBQl3UQVBCLyrIjsEJElIfb9VESMiPS02yIifxSRKhFZJCJjUjHpfGHhxr0A/Kdql7dP7QSKoqSbWFYEzwFnB3aKyEDga8BGR/fXgeH233XA44lPMX/5whYEiqIomSSqIDDGzAJ2h9j1MHAL4LR4Xgg8byzmAF1FpF9SZpqHDOpuBZH17FSS4ZkoilLIxGUjEJELgS3GmC8DdvUHNjnam+2+UOe4TkQqRaSyuro6nmnkPP27lQPwvVOG+vUbo95EiqKkj3YLAhHpANwG/CqRNzbGPGmMGWuMGdurV69ETpWzNLVYxuIDTa1+/epWqihKOolnRXAIMAT4UkTWAwOAL0SkL7AFGOgYO8DuU0LQ3GoJglK3/7+hvrk11HBFUZSU0G5BYIxZbIzpbYwZbIwZjKX+GWOM2Qa8BVxlew+dANQYY7Ymd8r5QzhB0KCCQFGUNBKL++hLwGxghIhsFpFrIwx/F1gLVAFPAT9KyizzlMaWtpD99U0qCBRFSR/uaAOMMVdE2T/YsW2A6xOfVv4yZ+0ubnhxATN/dpp3RTCkZ0cA3C6hpc2wr7Elk1NUFKXA0MjiNPPoh6vZua+RMx+aRWOzJQiOPbgbH/30NJ6ePBbQoDJFUdKLCoI0U2LbA7bVNnhVQ6XuIob26kSHkqgLNEVRlKSjgiDNFBeJd9tTjMYjHMqLi0IeoyiKkkpUEKSZ2Wt8eYWq6xopLhKKXJZw8LwqiqKkExUEaWa/wyNoxbZav+Axd5EKAkVR0o8KgjQzsHu5d3vV9n1++1yigkBRlPSjgiDNbNpd793uVOr2Uwe5Hduab0hRlHShbipppKa+2a9dVuziiP6dvW2nUGhtM6oqUhQlLeiKII18//lKv/a+xhY/l1GnINiw+wCDp0xjwcY91DY08/m6UJnAFUVREkdXBGkk8Gbe0NxGuaNMpVMQ/HullZr73mnLaTOGBRv3suyeszTWQFGUpKN3lTTR1hZa57/QUaWszWEX8NiN52/Y4+1rbjGgNWwURUkyqhpKA8YYTvndTG/bU5kMYMten/HYKSvcIWIK3l+6LTUTVBSloFFBkAY276n3u+EHFqLx0L9rOf27Wu6lodYPDS2alVRRlOSjgiANBIYHTBgRviLb908ZAsC7i4PLODSFSVutKIqSCCoI0oA4JMHSu8/i28cP8rb/evVxfmM9BuM5a4O9hLROgaIoqUAFQRpwGoo7lrrpXFbsbQ/v08lvrCtCvqE/TF+V/MkpilLwqCBIA54CNB5Kinwfe3FRYJlKVf8oipJeVBCkAU/dgcP6VgBQ7A6dVgJg5oodEc/V0qqCQlGU5BJLzeJnRWSHiCxx9D0oIitEZJGIvCkiXR37bhWRKhFZKSJnpWri2cS+xhYefH8F+8OUmPzB/80HYHgfSxC4Xb6P3R2wIiiOklZCy1gqipJsYlkRPAecHdA3HTjCGHMUsAq4FUBERgGXA4fbx/xFRPK+2srr8zfz55lrmDp7fdA+Ywwbdx8A4KZJw6w+h3NoSZAgiPwvueTxzxKbrKIoSgBRBYExZhawO6DvA2OM59F0DjDA3r4QeNkY02iMWQdUAeOSON+sZPf+JiC0ft+zD2BoT8sw3KtTqbcvMLFctFTUa6r3xz1PRVGUUCTDRvBd4F/2dn9gk2PfZrsvCBG5TkQqRaSyuro6CdPIHJ7n+1C38KodvpoDHo8gpztpoI2gY6lm/VAUJb0kJAhE5HagBfhbe481xjxpjBlrjBnbq1f4AKtc4PN1VvnJwIf51jbDZU/OiXisBBxUWqz2e0VR0kvcj58icjVwHjDJ+KqobAEGOoYNsPvyGk/wlwSsCdbt9K0GThja3W+fS/xzC3mIVo/m9nNGxjdJRVGUMMT1+CkiZwO3ABcYYw44dr0FXC4ipSIyBBgOfJ74NHMT59P+89893m/fWzeczKOXjw46pku5L9isoixYTjsNzbPX7OKZT9clY6qKohQwsbiPvgTMBkaIyGYRuRZ4DKgApovIQhF5AsAYsxT4O7AMeA+43hhTMHkRAlVDDc2+Sy9x+3/UR/TvwoWjg80nN58x3Lv99FVjg/Z7it1v2n2AK56aw6/fWRYUsKYoitIeoqqGjDFXhOh+JsL4+4D7EplUrhJ4Q/7X4vanjS4r9nnbHj+0h3e78pdnMPbeD2m19Ulrqn1qp9Y2Q3HeO+kqipIq1EUlQR750Jf/pzEgO+i22gYAPr99UrvOOfNnE7yBZX//wYks2ryXHh2tijQttiCormv0jm8NU/RGURQlFlQQJMgjH672bgemiV72VS0AvSvK2nXOIT07erfHDenOuCGWodntElrbrPf4+WuLvGN21DUyRN1OFUWJE/VVTCKNAYVjlm2tTer53UVCS2vw0//pv/84qe+jKEphoYIgiTSmOHOo2+XyqoYURVGShQqCJPLh8u0pPb8QvOpQFEVJFFUsJ8DOfY1+7dqGFuas3cXlT87hl+cmP/CrrrGFF+Zs5PN1/tXLTj00tyOzFUXJLLoiSID/m70hqG+5bRe4d9rylL3vqu0+19FeFaXUNTSn7L0URcl/VBAkQKhEoXUN/vUCTh7WM6VzGNitnNp6FQSKosSPCoIECGW3nbfeX21z4iE9ggclkRF9K6ht0GI1iqLEjwqCODHG8McZq4P6P1m9068dmGY6mbhdQueyYl0RKIqSECoI4uT9pf4eQq9cd0LIcX06ty+YrD1MGNGb4iKX5hpSFCUhVBDEyT8X+mfX7uGoOubhqAFdOO+ofimbwx3njaTIJbQZa4WiKIoSDyoI4sQZ2PXTMw8Nqj0McMd5o4KK0ydC/67lfu1SdxFFtupJ8w0pihIvKgji5JhBXb3bP540nGJ3sC0g2faB31x8pP/5i8QnCHRFoChKnKggiJPmFv8bb3GIJ3+3K7kfb6D6x+0Sr7DRFYGiKPGigiAOWlrbeNiRfhpCC4KmJBtx2wIFQZFLVUOKoiSMCoI4+GjFjqC+UDaC3hXBBuREaAhIaud2iQoCRVESJpZSlc+KyA4RWeLo6y4i00Vktf3aze4XEfmjiFSJyCIRGZPKyWeK+ubgxG+eQjIe3rphPAO7d0jq+54+ojdnHd7H23YKAs1KqihKvMSyIngOODugbwowwxgzHJhhtwG+jlWwfjhwHfB4cqaZXThrAnjiB4oCDMMDuiVXCACUlxTxv9/x1TEucgiCNhUEiqLESVRBYIyZBewO6L4QmGpvTwUucvQ/byzmAF1FJHWO9BnCqYbx1BWWgMRD7qLURRR7EPEZi3VFoChKvMSbhrqPMWarvb0N8Ogr+gObHOM2231byRMamlu55fVFUccVJ9ljyMl7N59CJ7s0pUvURqAoSmIkXI/AGGNEpN13IRG5Dkt9xKBBgxKdRto40OSzD5w4NHRCuYvH9KesOHWC4LC+nb3bHtWQpplQFCVe4r1bbfeofOxXjxvNFmCgY9wAuy8IY8yTxpixxpixvXrlTmGVFscN9/ffOjrkmIe+NTpIVZQqZtgeTE99sjYt76coSv4RryB4C5hsb08G/unov8r2HjoBqHGokPKCtxf5LqdTSeYLvO2ss6qkranen+GZKIqSq0S9k4nIS8AEoKeIbAbuBO4H/i4i1wIbgG/Zw98FzgGqgAPANSmYc0YZ0tPnDVQaoP559PLRSXcZjcaJh/Rg7rrdDO3ZMa3vqyhK/hBVEBhjrgiza1KIsQa4PtFJZTPO4N6y4iK/fReO7p/m2cBFo/vzyIerOX5o97S/t6Io+YFGFreD7bUNXDu1MtPT8MPjphqY+0hRFCVWVBC0g+N/M8O7fdf5ozI4Ex+e1BbNbeo1pChKfKggiJNJI/tEH5QGPPUOmltUECiKEh8qCOIkVLbRTODJcaSRxYqixEvm/R9zhMDI3TSFCUTFI5DeXLCFfY0t1NQ3c+f5h2d4Voqi5BIqCKIwc+UOhvfuxMyV1QCcPqIXE0f2SWlR+vbgEQRLv6pl6Ve1APzqvFFpC2hTFCX3UUEQgebWNq756zy/voWb9vLXa8ZlaEbBBGY9BatuQXlJUYjRiqIowWSHojtL2V7bENQ3vE9FBmbSPprUcKyEo2azfzCMopAngmD2ml38p2pn0s9b4g7+eB4Kk18om0h2iUwlT/hqITx8OFQ+m+mZKFlGXgiCK56aw5VPz43r2NY2w5eb9obcF+rBKRUFZxLlW2MH+LVVECgh2VVlva7/NLPzULKOvBAEiTD1s/Vc+Of/MGftrqB9gcXisxV3gCurqoaUiCx9A9bMzPQslCyi4AWBx9Nmw67g7J254po/bZF/gletTaCEZLcjVfmcvKwiq8RJwQuC17/YDIA7REWxwDrAPznz0LTMqb3U1Df7tXVFoIRk5n2+7QPBK2ClcCl4QeChtqE5qG9/U4tfO5VVx5JJowoCJRpbsit5opJZcuPOFoGlX9W0+5gvNu5h8JRp3PbmYm/frn1NfmPWVu/j7Ec+AXzG2JMO6ZnATNOHqoaUmGhpij5GKQhyXhC8OHdju8bva2zh4r98FnTskq9q/NJIfLLa54468bDerP3NORzRv0uCs00Nv/+mv0urqoaUmNi2KNMzULKEnBcEzuRvd/xjSdSb4NNhavt+vLKaxz+u8rbvfGupd7u0uAhXiAjebKFfF/90F6EC4RSF4V/zb4sLPn0EXv+etTp4+2aozavKskqM5LwgeO6z9d7t/5uzgY/sYu7h2L0//HJ4/oY9IfvLi7M7XYM7QEj9/DV90lNCsPoD/3ZRMXx4Jyx+FTZ+BvP/Ci9/OzNzUzJKQoJARP5HRJaKyBIReUlEykRkiIjMFZEqEXlFREqSNdlY+LSqOuL+arvYeyh6dCoFoL6p1a8/MPNoLrBiW22mp6BkE6FiYv7zqG97m20v++qL9MwnXtpaobEu07PIO+IWBCLSH7gRGGuMOQIoAi4HHgAeNsYMA/YA1yZjorHywpzINoN/Ldnm177y+EG8f/OpAHQtLwaCVSvZUnsgHKHk1A9fSOwHvWHXflUx5RM1m4P7Fr/q2969Ln1zSYT3psBvB6ihO8kkeodzA+Ui4gY6AFuBicBr9v6pwEUJvkdEDunVMa7j/vu0QwCoa2hhRN8KilzCp3a+Io/b6IQRvbj+9EM4bnC35Ew2jazbGRwg1x5Oe/Bjv9KcSq7jeFo49urg3ZXPWK+9RqZlNnHjyZPUGn5lr7SfuAWBMWYL8HtgI5YAqAHmA3uNMR4H/M1A/0QnGYlQT8Ph3Ccbmn0qn2MGdQWgRydLc9XaZlixrY4DTS1e1dC1Jw/h52cdlvW5/T1VyhQlLCum+bbHXRd+XPVyqMriB4A2+9ZSsyWz88gzElENdQMuBIYABwEdgbPbcfx1IlIpIpXV1ZH1+pFoaWvjxKE9/PrOefQT5q3fHTR2psOQfNqhvbj5jOHcfIZ/tPBtbyxmvy0IOuRITv9jD869FYuSZjZ85tsu7Rx57AsXwxfPp3Y+ibL580zPIK9IRDV0BrDOGFNtjGkG3gDGA11tVRHAACCk6DbGPGmMGWuMGdurV6+4J9HWBh1L/evrrN6xj28+MTto7BcbfV5BZcVF3HzGoXSx7QIeKjfsod5WDXUoyY26PeFWLKnU8X+4bDsHAiKvlSxm8MnW63mPWN5C0Vj2z9TOJ1Hc5ZmeQV6RiCDYCJwgIh3EuhNNApYBM4FL7TGTgZR9o6rrGtmytz7m8cN6dwJg1s9PD9r3i7MPA6DmQDP7G3NrReDk9R+e5N1OVfLU5Vtr+d7zldzxj6XRByvZQQd71XzwSUAMqsSBJ6R0OgnzxvcyPYO8IhEbwVwso/AXwGL7XE8CvwB+IiJVQA/gmSTMMyRz11mJs3btj81wtPeAlU+oe6dgj9ZrTx4CwMVj+nszkeZiucfD+voqqLlTZDvYY8dibNl7ICXnV1JAi/0bcZdCRZ/o47sdnNr5KFlFQroPY8ydwJ0B3WuBtBT19ah1Av3+PTQ0t1LmCAarqW+myCV0DHGD91Qjmzp7g7evY46ohpw4axi74jRyt0TJVbTLFgTZ7larOOg+BEb/l88+UFIBTRH88dtC/6aU/CSnf8keHf6KbXX87pKj+OvVx/ntP+yO9/zaNfXNdC5zx+wFlO0RxU4evuxorj5psN/N38SpG2qIkqbjxy8tsMY1680iZzj4JLjoz9Chu9X+yVLoPjT8+JbYVa5ppTj7KgTmA7n3yOugf1efwehbxw2Mai+obWgJMg5HIpvzCwXyjWMG8I1jBvhFQcdrIrjJvtGDJTzDfWal7twRlEoAZV2gNYKxv6H9WX1TztYvodlWR/Ybndm55Bk5vSLo26WMqd8dx5xbJwHBhWSOHtjVrx3pppYvOGVXPAuChuZWZjjcbI+++wPmrd/Nzn3BdpiDe+jTWU5TEyYKv6gU6kPn3coo857O9AzylpwWBGDFA/S1s2927eC7yQ/v3YneFaV+Y2vrm+kcQRCsv/9c3r3xFMDnYZRrONVeJo41QahgvFmrqhl774e8Wrkp4L3aPz8lB2ht9M9DlC1snu9o5F7+r2wm5wWBk4qyYt740Un84/rxrN6xj+nLtnv3vblgMws37Y0oCABGHdSZF793PK/+4MRUTzf1xPFbaW4NPuhPH1npuWeu3OG36lLVUJ6zJcsS0O2w3ZUHnRR5nNJu8koQAIwZ1I3RA7t61ULGGN5csJn/eeVLACpKo5tFThrWk24d05o0NSXE88wUyWNIEB6b6avZEFgrObCt5CBHX+Hbfio43iajHDzeei3rnLogmQIl7wSBh3OO6AvAgaZW7nl7mbe/PQFouc7mPbH7+be2GWav2UVzpJTb4p+99bX5voyWs9fs4ui7P+D9pdtCHankAj+YBd94AvoeGX3svmpfbEK6KO4ABx1DTAFxSrvIW0HgMQrvrW+myOW7zJXbCieX+auVIVIPh+HPM6u44qk5zFoVPu+TED6h3y//YeWzf3+JCoKcpYNdk3vb4sjjAH4/DF6+MrXzCaS5Xt1HU0TeCoJG2xf+5c83+nm8PHdNWmLdsoL2RBZ7Ctls3B1+FSEiHNQ1dI6XM0Za0apD40wLrmSA3of7t912ydNug319rS3wzk9gjy/Q0quWqZoefM5UBqI1H4Biz/dPVUPJJG8FgSfhmsfQCTBmUFdGHRQl82IeIe1YQnuMxLv3hS/4IRB2xeCJaM72lN2KE/tm6rIdKDra+YiufN03pOpDq1bB2zf5+lrD2IK2fAH3dIenz4AZ90BDkqvkNddbgkC/Y0knbwXBRccEl0G4cHRKSyNkHe1xH/WofFrtp71xQ7oHjdlR18Ckw3r7/Q49x+nzWQ5ibDXf96bDLY4KZT2H+bZ3rbZenf/0cEVhPKmuN8+DT/4AM+5O3lzBXhHYK079wiWVvBUEh/apCOq76sTCSqTVHseKj1daT/pVO/YBcNnYgUFj5qzdTXOb4aj+Xbx9LQHupoFtJYsps/+PxR19qSc8nP2A9frBL63XNR/59oUzEn9wu3+7fm/75/T5U7Dk9dD7PCsCNRYnnbwVBKEoNLVFLLfkpV/VsKZ6n7e9cJP14x0/rCcrfn02d54/ym98XUMzFWW+WAzPCsKTdyicMVnJQr45Fc78NfQcHrxPAm4NLkf8zf6dsZ2/LY56Fe/+DF77buh9aixOGXktCK4+abB3+/nvFo6RuGcnK6I6lhXBuX/8lEl/+HdQf1mxi7LiIq4ZP4T1959LqdtF/67l1DW0UFHmi8VotVcANXaK7yYVBLlD534w/sbQOvfAvr5HWK8tTfCX4339TRFclJOZr8gYNRankLwWBM7CMkN6Fo43y3A7PUa0vEqNLeE9PAKjhscN6U6vilJ7ReDm9BFWVbnmNuvG7wkmi+R+quQytmBo2uffXRuhdnAicQarp8N+q94IxsDSN8C0qrE4ReS1IFhbvd+7PaBb4ZS2+5WtzhnZL9hO4qS6LvwPtdTtCmo3tbTZK4JizhhluYt6sp022EJlRQHFaeQ1gSmqy+262LVf+fevmObfdtZDTiSV9d8uhZcug70b4dmzfOoij2pII4uTSl4LglXbfTelQrIPeIrxtEX5sbRF0OIEpuAucbtoaG7lQFMrFWVuiu0gvRZbEITKUaTkMIdM9G+77BXiE+P9+zvbnnjGgBTZkb82Xy0gIapXwiNHwqa5vr7iwnmgSyd5LQh6BWQfLRSKbKEXTV0fTVA4cbtcrN1prbA6lri9gmLjLktH7MlR1D1MjiZjDLe9uZj/VFmGxsWba7wlL5UsRARu2+prt4b7XxkrfmDdvy3VTafe8b9n4PexMUQcwrpZ8Z9fCUtCgkBEuorIayKyQkSWi8iJItJdRKaLyGr7tVuyJtteHrncKl4R6PmS73gyagTWZwikJdKSIIC3F/lUAu4iYd1OS1d8xVNz7HPZAWn7m3hn0VdBx7e0GV6cu5Ern7ae7s5/7FPOekR/1FlNSQe47SsYcFxwEJknOd2sB63kdM9faLU90cnxEFbYOPDaKHQFmkwSXRE8CrxnjDkMOBpYDkwBZhhjhgMz7HZG6NelnPX3n8s144dkagoZwVOuMtoTf2OUkpROnKc60NTqZ0zes7+JRZt9HiI3vBisEnCmBF9tq+x2RLBRKFlCSUco6RQsCHatsV53rvLvD3QZrd8be9qJpv3h93lsFpc8rcbiFBC3IBCRLsCpwDMAxpgmY8xe4EJgqj1sKnBRopNU2ocn3UNrFEHQFEYQ/PysERGPc4nQ0ZHO+9X5myKMtnh+9nrv9jY7/YeSIxSVWE/rdT5hzlHfCj2280H+7QcOhvdvi+19Pn04/L5zH4K7anxBcGosTiqJrAiGANXAX0VkgYg8LSIdgT7GGI9ycRvQJ9FJKu3DuyKIohoKFAQ/OG0oD33raH404ZCIx31aVe1XEvM3764IGhNY12B/o++psDXKvJQso6jYEgQr3/X1jbkq9Ng+h1s3bCdzn4jtfTwrgmP+C/oe5b+v1OkBpyuCZJOIIHADY4DHjTHHAPsJUAMZYwxhlHkicp2IVIpIZXW1+p4nE8+KINr9tiVgQOeyYi4eMyCqh9X1pw/zCptwNAQImT6dfbrjF+f6auVGE1ZKFuByW+odl70K7DHMWiWE4vCLrdfRcaSo7mNnQz1tCmxb5L8vEduDEpVEBMFmYLMxxuPb9RqWYNguIv0A7NcdoQ42xjxpjBlrjBnbq1evBKahBOJ5Wo/25N2edBCdHKqgkw7piSvKQ9m7i7f6tdfu9AUifeCwF8xZu4tjfz3dazdQshCX29L9l9hBmRc/GV5P7+l3xVHGtNmOUi7vGuK8gbcqfYBIJnELAmPMNmCTiHgUypOAZcBbwGS7bzLwz4RmqLQblys2Y3GgoIgkON78kX+d2MA4A/CP5N7lSGfd0NzqF9zn5NtPz2XX/iaen70h5H4lC3C5oa3ZFylcHsIR8JvPweR3fO1tS/z3NwZEJIei2Q5Ac4eIFXDaHtRYnHQS9Rr6MfA3EVkEjAZ+A9wPnCkiq4Ez7LaSRnxxBNHcR2MXBAO6+Sf7CqUa+vhnE7zb9U0tXPvcPOqbWtnXGEfyMSV78KiGWmwjfyg1zeHfgCGn+NpfBRS+b4xhxde031I5FbmhwnHjv6smeJWgxuKkkpAgMMYstNU7RxljLjLG7DHG7DLGTDLGDDfGnGGM2Z2sySqxEauNIFAdEylhXElAyonjBgc/FfbuXMbfvmclJPvjR1XMWLGDD5Zti6movT7kZTFFtmrIsyKIR18fmKMoFM7sotd+EGGgflmSTV5HFhcqnptqNNXQ7z/w9wFfWx3+x+oRLm77dVjv0HmMigJURk0tbWzYZamFPInqQs454kyVjOJyw77t8N4vrHY8giCWamXN+32CoMuAKIN1RZBMVBDkIbGohkwIIXHvRUdGPO9d549i2o2+5f/FY4IrvgUKguZW410R3HFeYUV45w0ut3/bbaduGfeD2M9RH4NioG6779wiUN4dhp0ZPE6Xj0lHBUEe4g0oiyAIQqmBouVmunr8EEb09a0E7r3oiLDv7WHD7v3eeAWneunBS4/yEySePEZKFhIoCDweQaf9IvwxgQbf5iiZSFe+B1XTYY+jZOZNC+Hbr8Q+TyVuVBDkIZ44gFBP/R6ufGpu2H2x0qHEd4PwqIzqGvwNw//777XUN1nBZE5B8M2xA3noW6O97U9W72T+BjUnZSXhXEFLbDVOv6ND7Az47rVEiSZ/6bLgvrIu4d9bjcVJRQVBnlLkkogpJio37PFuP3fNcXxyy+kJvd/yX58NwFd7g5/87np7GWAVuzl6QBe/ynGzb/WlOyEPQY0AABnjSURBVL762XkJzSFVfLFxT0ShmvcErgg8FJfDla/Bt/8evK9rQH3wwFxFCaGqoWSjgiBPKRKJmobaw+iBXRnYPf5asP27llNcZH2VRvbrHHZcqdvFP284mbsuONzb16+LT4VQl4VupjOWb+fiv3zGS59Hz6eUt4QTBADDz4SKvsH9k9/yb8eSWbRdFLBgTgEqCPKUptY2nv3PuugD8Y8abi+zb53Iv272GZBHD/T5e18xbqDf2JKiyF+3g3ukrjB5bUN8T6SbdlvRrsu3xuD1kq9IHFHCFX1h4h3wnTetdqwrghOuj2E+uiJINioI8phw2UUDcUe5QUeiX5dyOpf510Z+9PLR/OumU+jR0d/4HCoa2clph0ZPNTJzxQ4+WrE96jgnS7bUcNRdH/D2l8F1EmKloO89zou/rR2f4ak/g/7HWtueFcGmz4OL2jcd8G2f+KP45qgkhAoCJelcOLo/I/t1pmpHDEFEDgIjnUNxzXPz+O5zle0674JNewG81dHag2dGscwtbzGOBwpPvqFY8SSna22yAtKeORNeDkhI56xEFjV+wDOnAv5/pAAVBAXOlccPStm5nQ+S7998atTxzVFWMM5Mpe0x3npKYr48LzY9/6MfruaT1VZGXM9bOjOmFhyeYLBjvtP+Y72CoBnWfGRtr//Ef0w0j6IgCnl5lhpUEBQ4930jchBZIpQV+3TLzviDQJ6ZPBaIng31QLOvpkF7DMsr25nZ9OEPV/GdZz4HrIR5BY8nK+hBoyOPC4XH/XNXFbx0ua9/52rf9r6QCYqjoCuCZKKCoABJlyuk533uvziysJk0sg/DeneiuTXyvPY7bv6fxajmqalvZtqircH9B5qDaiE0tbTx9Cdr/foONPne83tTs9O9NX0k8CS+OMDF9LGxvtxFsSSk85uGrgiSjQqCAmRNmJTQycaToTQw2jgUxUWuiEnvAL8spp3LiyOM9LFzn39d5KaWNnbua+Toez5g0kP/BmBHXQMrttXyjwVbuHfacu/YhuZW/rHAZxz9cPmOmBLoKTEy60Hr1bPiOP+PmZtLgaOCoAB55tPY3EoTZXBPy7DYM0rqCoCSIvFTDW3ZWx/0xP6dp33R0I3NsXlEBd649ze2sN2umbxu536OuPN9Jj87j7Mf+YT6ADXQYXe8x5aAALmvPzIrpvdVYsCjEvJ4DQ0+OfZj1VicVFQQ5DkXPPZpiN70/Ih+NOEQnr16LBNicAstLnJ5BcHWmnrG3/8RD033z476VY3PqBjJRmCMYeW2OhpbWqk54C8I9jW2sNfRt6+xxRsjEIvGwTkHJUGKiq06BzuWWu3iWONIVDWUbFQQ5DmLNtcE9bXZD9N9O6e2Dqy7yMXEw/pErYEMtiBosQRUbb11k39/6Tbv/h+/tMBv/I0BbSc3vLiAsx6ZxYhfvseTsyyd/yVjLLfEHXWN1IZR73y+Lnyuo4mH9QagvLgoYrru/CbOB4hwkcnuMvj3A/CfR612SXsCCnVFkExUEBQgnjoF2WRzq29u5fP1uzHGeOfl/KmHCgbbURv66Xyao17y7LW7AF/Cu0se/yxsxbR3QhiVAV7/4Yk8e/VxlBcXUd/cysQ//Dva5ShOTvpx6P7ybrDO4UpaHGOMQjZ9cfMEFQQFiCfAKpt+TgvtOc1eu8s7L4/XUaCtwMPU2euD+haHWAGBf7yEx25w9IAuIcd++JNTuf2ckQBcMW4Qxx7cHcDPhvDxynhcHnOURG+8rjCG/eZ6/2C1ovhTnSiJkbAgEJEiEVkgIu/Y7SEiMldEqkTkFREpSXyaSjLxRPyee1S/DM8kmMbmNl8abbvvX0u2hRz755lr/No1B5o5P6RNBA7t44tjWLHNcld89PJjgsZ1KCliWO8Kvn/qUNbffy6/DeP6evVfC8iVdIgdDNg3VLrpGHAKkgsegzPutrY/+T1smhPfOdVYnFSSsSK4CVjuaD8APGyMGQbsAa5NwnsoKeCqEwdnegpBNLe2+VRD9m/9xpfD2wOc7D4QPsOlsxZCXUMzJW4XPTr5nlGG9+4EwIGm2API6uJMZJdzHP4NuGUdDDwuzhM4BEHvkXDyzQlOKJvWsvlBQoJARAYA5wJP220BJgKv2UOmAhcl8h5KfDzxX2OijonFvz/dNLW2eQWAx5bRo6Pvhr307rNYfo9V++C6U4f6HRtOXXPPhVba6z9803qifX/pdlzin3X1vm8cSZ/OpUy7MbwL40c/PY3nrvHdDF+t3BzrZeU+Hbon5zwmxtzo0U+UpPMokPiK4BHgFsDz3+0B7DXGeKxxm4HgwraAiFwnIpUiUlldXZ3gNJRAykv89a1b9tYHRRS7s1AQlBS5vPP0pHe48niryMnKe8+mY6mb8hIrbcFHK/xv/N07BmshH79yjHfl44wpaHCooAB6diph7m1ncPhBoe0GAEN7dWLCiN68+aOTALjnnWXtvbwCxfG9a2kMPeSCx2I/nRqLk07cgkBEzgN2GGPmx3O8MeZJY8xYY8zYXr2i+5kr7cN5k//2U3MYf/9HvBCQOK3UHUee+RTz5Ky13vrF22sbWbGtlsaWVoqLJGi+0bKbjhvcnbMO9xVNuey4gUFjPG6l/buVB+0LxzGDunm392dhMZ2sJlz20jFxJLRTkkYiK4LxwAUish54GUsl9CjQVUQ8j6MDgC0JzVCJC6cg+GyN5UI5L8BPvkNp9giCYbaOvnLDHn7wf75ni7Mf+YS/fLwGiUEv3OjIXvrP68fz9/8+0a8GQscQBXjuvGAUM382IW6hePid78d1XEHSbzT0t1WWZ9+f2LlUM5RU4hYExphbjTEDjDGDgcuBj4wxVwIzgUvtYZOBfyY8S6XdhCo2E2gTyCbV0F+vjmyIjJaHCPwL8Yw6KHzJTCedy4oZ0rOdOfaBn555aLuPKXhGfN23fcIP4aDodqzQZM/3Nl9IRRzBL4CfiEgVls3gmRS8hxKFUDd5V4BuNZaI33QR6mk9Emcd3ieozyMIPpsy0VtDOVVcf/ow7/b3n68s7OL28dKe3EJB6OedTJLyazHGfGyMOc/eXmuMGWeMGWaM+aYxJox1SEkl7qLgm3yRC1pirWifZkrd7fsqHmEbdRtbWtmwy7IpeFYNXTuEz0z6+e2TuOO8UUz/n+iFciLhcom3JvP0Zdu5++1lXPr4Zxx5V3hV0ZsLNjPk1ml+qa0LikBhOenO+M6TRQ8w+YJGFucpoZ6Ii1zip0fPJjqWuplk5/OJhU17rIyVI375Hqc9+DGrttd5K5yVRFgN9K4o49qThzC8T/hCObHSrYPPS+m5z9ZTuWEPdQ0tYYvZ/M8rX2IM3vxHYAmyh6evyu+YhHCrpSI3jL4SJtya3vkoQaggyFNCxQi4xCcI7r7g8HRPKSqRqpgFEljEZsueeppa23BJaPtIKvj+KUND9s9YHhzP4Eyx/ciHvupc7y3ZxqMzVnPP23nsitrXjs7ue0Twvov+AhOmtP+cqopLKioI8pRiV/C/try4iMYW62m1vaqYdNCeoi+TTxoc1Penj6pIZ435bh1LmPHT04L61+/yL/xT39TKc/9Z79e3yi6fedPLCwF4dX4eB6eNugCunwcjz0/SCVU1lGyy726gJIVQNgKDr6BLaXH2/ev/5ohz6B2lmM3ogV392i3plAAODunVybt9ZP8uFBcJm3Yf4JDb3mXwlGm0tLZx2oMzue/d5X7Hfe3hWfmtDgqkV7K9rHRFkEyy726gJIVQgqCxpZVa++aTjcFkTkIFf0Vi8ea9KZpJdDqXWR5Pf7lyDM2thpfnbaLVFkw19c3sqAvtL3HkXR94t7vEWHpTQRcEKUDzvuYp7hCqob0HmtnfaKmGsvHGM35YD/5TZQW/Oed/4eiDvBHATkb168wyu7qY5/UGh1tnuvjijjNpaTOUFQcL1+c+W+/XPu3QXvx7lX9KlT6dS9le28i+xha//EdKBNRGkFR0RZCnhFoRvLNoq/dJtSQLbQRnjvTFBjhXBI9efgynhih3+c6PT2bhr84EYO5aK2r67CP6Bo1LNe4iV0ghAJbdwsnTk8dSHPC/GdDNqsy1Z38TT81ay8Q/fJySeeYPuiRINvr4kaeEc6FssetUZmPmUeczXt8uZbz63yfSLUJMgMsldLVdOD01jDuXZd9Kx8P6+88F4JNbJnLCb2d4+zvYSfRO+d1Mb19NfXNWrtqU/CT7HguVpFBWXOSnZph0WG+O6N/ZuyLIpvQSHgJX+8cN7s6w3u3z9+9cntlnmwcu8RWycX7GnlTYYAm5y8b6VjwDQiS802R20VDVUDJRQZDHvP1jXwh/kUtYsqWWa6dWetvZhie9dCJ07ZDZgniXHTeItb85hwV3nMmUrx/m7Q9Mb/3ApUex7rfn8P7Np3Jk/66Bp2GlXUVNCYFGFicdFQR5jFMXvT3AcyWUMTnTXHqsZRBubxK4iiwzsLpcQreOJUwY4YuU7hBCyIkII/pWcMHog4L2/fcLcWV3LxzUWJxUsusXpCQVp52gKSC1RDauCIqLXF49envoXF7stRFkE8N6d2LFr8/mszU7GdkvfDbUTqVu1t9/LoOnTPP2dVb7QASy77ub62TfY6GSNJz5hkoCPFWyURDES4Xtx//4lfGmNU4dZcVFTDwsOFNqNKrrGnlvybYUzEhRglFBkMc4XUgDk9Blo7E4Xm4/dyR9O5dx2ojcrnR35/mj/Oowq3ooEqoaSiYqCPIY580/UBDk04rglOG9mHPbJDqU5Lam85rxQ7jtnJFeWwnAz1/9MoMzylLUWJx0VBDkMU4bQaBHTj6tCPKN33/zaM4YaRma8zoZXSKosTipqCDIY5z1euub/HPk59OKIB/ZvKfeu63VzwLR726yUUFQIMxeu8uvXZyFKSYUHw9ccpR3++V5mzI4E6UQiPtuICIDRWSmiCwTkaUicpPd311EpovIavu1W/KmqySLTjmuT893jh7YlYvs+IKv9tZHGV2I6CopmSTyWNgC/NQYMwo4AbheREYBU4AZxpjhwAy7rWSIn581gtd/eKJf30FdyvzURkp28rOzRgBWCooDTS3tKtzjYdqirSz7qpZ1O/dHH5wrqLE46cT9WGiM2QpstbfrRGQ50B+4EJhgD5sKfAz8IqFZKnFzvZ2WuaLMTV2DFXQVLlOmkl1U2An06hpa+OWbS3hjwZZ2B9xd/+IX3u1Pf3G6N9NpztMeu8nK96DncOg+VIVIGJKiHxCRwcAxwFygjy0kALYBIaNpROQ64DqAQYMGJWMaSgRe/+FJ/GPBFgzwrbHtK/qiZAZP0sDahhbeWLAFgMr1u1m+rY7vnHBw1OMffH+FX/vkB2bGFbmdfdg3882VMOtBuOhxEBe4S6E4IIHfkjfgtWt87SmboCx8lHehIol6JIhIJ+DfwH3GmDdEZK8xpqtj/x5jTEQ7wdixY01lZWVC81CUfMSZdsJJtBt6vMflBO/8BBa8AK0hKr9d9RYMtetI790Ejxzhv/+yF5JYOznziMh8Y8zYRM+TkOuIiBQDrwN/M8a8YXdvF5F+9v5+wI7EpqgoSiDn/+lTnpq1lobm1qhj25vELycIJQQAnr/At719afD+j+9PzXxynES8hgR4BlhujHnIsestYLK9PRn4Z/zTUxQlFIu31HDfu8t5aPqqoH2emhMAd50/ipk/m8AV4wYhAm1teeBts/nzyPvXfwp3dYGXLrPat6yDk260tkddlNq55SiJrAjGA98BJorIQvvvHOB+4EwRWQ2cYbcVRYmDK4+PbD/bs78pqG/ys9aN8o7zRnH1+CGAlQnVGKhtaL/nUdZR44i2nnCbb7tDD+v1uQD1V4fucOY91vbMe2Hxa6mdXw6SiNfQp4QP8ZsU73kVRfFx0TH9+dvcjWH3VwSU5tzX2MKnVTsBWLG11tt/2XEDufiY/vlR/vL6z+H3w63tE34IJR3hwE4Y/V/w2LH+Y7vaRnWnt9Dr18KwSVCuIU4eNLxUUbKYQd197p4nDrWeeOfdfoa3r1OZG2MMg6dM49w/fsJWR/DZycN7+saVuunWsQTJB/fJTr3hilfg3D9YHkAn3QBn3AU9h8EhE60xlzwDUzbCjQt9x/Ue5dte9hbsXJ3OWWc1CXsNJQP1GlKU8MzfsNtb2Ka6rpGDe3TkDx+s5E8fVYU95rC+FUy78RTNKRVIzRZ42CEQ7tgFRbkbZZ8VXkOKoqSeYw/uTocSNx1K3Bzcw/IAumHisIjH3HvRESoEQtGpt3/7d0N821nwUJwpVBAoSg5S6o4cHT6ib0WaZpJjFBVDj+G+dmMtNO2HJa/D3V2hbltBCgQVBIqSo1wxzhchfuzBPsPn+vvPDTIiKw5+XAl31VjGZYAdy+G171rbL1xiCYQlb4Q/Pg9RG4Gi5DDGGBpb2qhtaGbcfTM4rG8F7918aqanlRusmAYvfzv8/pu+hG6DE3+fLfOh32hwJT/Hl9oIFEVBRCgrLqJ3RRn3X3wkT12V8D2hcBh0YuT9jx4NO8Mb5GNi+dvw1ET44Jf+/ft3Qksj7A3vGpxOctdcriiKH5eP0+SN7aJDd7hpEfzvqTDi6/CNJ6CtzUpfcV9fa8xjx1puqGVd4nuPhS9ar7scAmXVB/DiN33tn66CipC5OdOGCgJFUQqXbgdbKSg88RUuF7jKYcKt8PFvrb77QwjYS56BIy6Jnta61whY+S401vn6VrzjP2bVe3DsZDKJqoYURSlsXK7gG/qEKfDD2eGPef1aeOlya7t6JWz5wvI+eu48qPwrzHkC2lqh6YA1ZsdynzfSF1P9z1W3lUyjKwJFUZRQ9BkVef+q92DRq/DG9/z7139ivb7nqMfVsBdqNsFnj/n67qqxhEUKjMjtRQWBoihKOH61B165Es59CDr3s/pamy2d/19OCBYCkXjkSN92eXfrNQuEAKggUBRFCY/LBVe85N9XVAy9R8KJN8Dsx6BjLxh/M3xwOww+xUqCd+hZsGcD9D3SimaeGlAMx5MNNUtQQaAoihIPZ91n/YHlbdT3CBhyWrC9ITBWa/xNMPrK9MwxRlQQKIqiJIrLBUMnhN4nAkNPh4q+lotqFqKCQFEUJdVc9Y9MzyAi6j6qKIpS4KggUBRFKXBSJghE5GwRWSkiVSIyJVXvoyiKoiRGSgSBiBQBfwa+DowCrhCRKNEZiqIoSiZI1YpgHFBljFlrjGkCXgYuTNF7KYqiKAmQKkHQH9jkaG+2+7yIyHUiUikildXV1SmahqIoihKNjBmLjTFPGmPGGmPG9urVK1PTUBRFKXhSJQi2AAMd7QF2n6IoipJlpKRUpYi4gVXAJCwBMA/4tjFmaZjx1cCGON+uJ7AzzmPzAb3+wr3+Qr520OvvCXQ0xiSsUklJZLExpkVEbgDeB4qAZ8MJAXt83BciIpXJqNmZq+j1F+71F/K1g16/ff2Dk3GulKWYMMa8C7ybqvMriqIoyUEjixVFUQqcfBAET2Z6AhlGr79wKeRrB73+pF1/SozFiqIoSu6QDysCRVEUJQFUECiKohQ4OS0I8jXDqYg8KyI7RGSJo6+7iEwXkdX2aze7X0Tkj/ZnsEhExjiOmWyPXy0ikzNxLe1FRAaKyEwRWSYiS0XkJru/UK6/TEQ+F5Ev7eu/2+4fIiJz7et8RURK7P5Su11l7x/sONetdv9KETkrM1fUfkSkSEQWiMg7druQrn29iCwWkYUiUmn3pf67b4zJyT+s+IQ1wFCgBPgSGJXpeSXp2k4FxgBLHH2/A6bY21OAB+ztc4B/AQKcAMy1+7sDa+3XbvZ2t0xfWwzX3g8YY29XYAUmjiqg6xegk71dDMy1r+vvwOV2/xPAD+3tHwFP2NuXA6/Y26Ps30QpMMT+rRRl+vpi/Ax+ArwIvGO3C+na1wM9A/pS/t3P5RVB3mY4NcbMAnYHdF8ITLW3pwIXOfqfNxZzgK4i0g84C5hujNltjNkDTAfOTv3sE8MYs9UY84W9XQcsx0pYWCjXb4wx++xmsf1ngInAa3Z/4PV7PpfXgEkiInb/y8aYRmPMOqAK6zeT1YjIAOBc4Gm7LRTItUcg5d/9XBYEUTOc5hl9jDFb7e1tQB97O9znkPOfj73UPwbrqbhgrt9WjSwEdmD9iNcAe40xLfYQ57V4r9PeXwP0IHev/xHgFqDNbvegcK4dLKH/gYjMF5Hr7L6Uf/e1eH0OYowxIpLXfr8i0gl4HbjZGFNrPehZ5Pv1G2NagdEi0hV4Ezgsw1NKCyJyHrDDGDNfRCZkej4Z4mRjzBYR6Q1MF5EVzp2p+u7n8oqg0DKcbreXfdivO+z+cJ9Dzn4+IlKMJQT+Zox5w+4umOv3YIzZC8wETsRa9nse3JzX4r1Oe38XYBe5ef3jgQtEZD2Wqnci8CiFce0AGGO22K87sB4CxpGG734uC4J5wHDbo6AEy1j0VobnlEreAjzW/8nAPx39V9keBCcANfYy8n3gayLSzfYy+Jrdl9XYOt5ngOXGmIccuwrl+nvZKwFEpBw4E8tOMhO41B4WeP2ez+VS4CNjWQzfAi63PWuGAMOBz9NzFfFhjLnVGDPAWInULse6lispgGsHEJGOIlLh2cb6zi4hHd/9TFvJE/nDspqvwtKh3p7p+STxul4CtgLNWPq9a7F0nzOA1cCHQHd7rGDVh14DLAbGOs7zXSxDWRVwTaavK8ZrPxlLT7oIWGj/nVNA138UsMC+/iXAr+z+oVg3syrgVaDU7i+z21X2/qGOc91ufy4rga9n+tra+TlMwOc1VBDXbl/nl/bfUs89LR3ffU0xoSiKUuDksmpIURRFSQIqCBRFUQocFQSKoigFjgoCRVGUAkcFgaIoSoGjgkBRFKXAUUGgKIpS4Pw/Ced1oetX7+cAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "cpcv = CPCV(dataset, N, k)\n",
    "for e, (train_ids, test_ids) in enumerate(cpcv.split()):\n",
    "    dataset_train, dataset_test = dataset.iloc[train_ids], dataset.iloc[test_ids]    \n",
    "    plt.figure()\n",
    "    plt.plot(range(len(dataset_train)), dataset_train.close)\n",
    "    plt.plot(range(len(dataset_train), len(dataset_train)+len(dataset_test)), dataset_test.close)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Modeling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "processing split 1 / 15\n",
      "processing split 2 / 15\n",
      "processing split 3 / 15\n",
      "processing split 4 / 15\n",
      "processing split 5 / 15\n",
      "processing split 6 / 15\n",
      "processing split 7 / 15\n",
      "processing split 8 / 15\n",
      "processing split 9 / 15\n",
      "processing split 10 / 15\n",
      "processing split 11 / 15\n",
      "processing split 12 / 15\n",
      "processing split 13 / 15\n",
      "processing split 14 / 15\n",
      "processing split 15 / 15\n"
     ]
    }
   ],
   "source": [
    "cpcv = CPCV(dataset, N, k)\n",
    "\n",
    "ALL_P_TESTS = []\n",
    "ALL_RETURNS = []\n",
    "ALL_DATES = []\n",
    "ALL_MMCS, ALL_PREDS = [], []\n",
    "FEATURE_IMPORTANCES = []\n",
    "\n",
    "for e, (train_ids, test_ids) in enumerate(cpcv.split()):\n",
    "    print('processing split', e+1, '/', cpcv.get_n_splits())\n",
    "    dataset_train, dataset_test = dataset.iloc[train_ids], dataset.iloc[test_ids]\n",
    "    imp, IMPORTANT_FEATURES = calculate_important_features(dataset_train)\n",
    "    X_train, Y_train, P_train, T_train = createXY(dataset_train[FEATURE_COLUMNS], dataset_train['close'], training=True)\n",
    "    X_test, Y_test, P_test, T_test = createXY(dataset_test[FEATURE_COLUMNS], dataset_test['close'])\n",
    "    mmcs, pred_prs = train_and_evaluate_n_times(X_train, Y_train, X_test, Y_test)\n",
    "    bagging_strategies, bagging_returns = backtest_predictions(pred_prs, P_test)\n",
    "    ALL_RETURNS.append(np.array(bagging_returns))\n",
    "    ALL_P_TESTS.append(P_test)\n",
    "    ALL_DATES.append(T_test)\n",
    "    ALL_MMCS.append(mmcs)\n",
    "    ALL_PREDS.append(pred_prs)\n",
    "    FEATURE_IMPORTANCES.append(imp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Probabilistic evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_results = []\n",
    "for b_ret, s_ret, dates, mmcs, preds, fis in zip(ALL_P_TESTS, ALL_RETURNS, ALL_DATES, ALL_MMCS, ALL_PREDS, FEATURE_IMPORTANCES):\n",
    "    res = calculate_all_metrics(\n",
    "            np.array(b_ret), \n",
    "            np.array(s_ret), \n",
    "            [datetime.strptime(date, \"%Y-%m-%d\").date() for date in dates],\n",
    "            mmcs, \n",
    "            fis\n",
    "    )\n",
    "    df_results.append(res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_results = pd.DataFrame(df_results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAEICAYAAABPgw/pAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAfuUlEQVR4nO3de5gcdZ3v8fdnIYLhEjQZJZKEELkosHJx5Ooia/AYMNwUYxDQ7Ao5hxUWXF0eYF1gOXsQeRRUUDhRMKAIREw4IUCURCBcQsgQB0gIwRDCJmwCSYBAjCDR7/mjKtI03dM9M93zm+7+vJ6nn3RX/epXn66ZfLvmV9VVigjMzKzx/U3qAGZmVhsu6GZmTcIF3cysSbigm5k1CRd0M7Mm4YJuZtYkXNCt35G0SNLhqXNY9SSFpF1T52h1LugtQNIXJXVI2iBplaS7JH08n3eRpDfzea9IekjSwQXLDpV0bb7ca5KekvQfkrbJn/9jifWdJamjTJblko4omjZB0gObX0fEXhFxb4X3NDIvIlt2c3NYN7lYNw4X9CYn6V+A7wGXAO8HRgA/Ao4taHZLRGwLtAEPAFOVeS8wF3g3cHBEbAd8CtgB+CBwPfClEqs9JZ/XsPxBYQ0pIvxo0gcwCNgAfL6LNhcBPy94vRcQwBDgP4EngL8ps+wwYBOwc8G0PYE/AUPKLLMcOKJo2gTggVJtgAOADuBV4AXg8nz6f+U5N+SPg8l2UL4JPAe8CNwADCro90v5vHXAvxet5yLgVuDn+bpOzdc9F3gFWAVcBbyroL8A/gn4PfAa8L/JPugeyvuYUti+xHt+ELgi738ZcEg+fUWe/8sF7SeTfRDflb/fB4EdyT6sXwaeAvYraD8cmAqsyd/vVRV+V3YF7gPWA2vJPuQB5uTv8w/5er+QT//XfJv8N/CPeZtdU//Ot/rDe+jN7WBga2BaNY0lbUVeUCJiLXAEMDUi/lKqfUSsBO4h2yPf7BTgznz5Wvg+8P2I2J6sWE7Jpx+W/7tDRGwbEXPz7BOAvwdGAduSFWEk7UlWEE8ChpJ92O1UtK5jyYr6DsCNwJ+Br5F9uB0MjCYr4IU+DXwUOAg4B5gEnExWUPcGTuzivR0IPA4MBn4B3Ax8jKy4ngxcJWnbgvbjyD6whgBvkH3YLMhf3wpcnr/XLYAZZB9eI/P3eXMXOSD7MPoN8B6yD+orASJi83beJ9/Ot0gaA3yD7K+13ch+T6wfcEFvboOBtRGxqUK7cZJeIdsz/ChwfMHyqyosez15QZf0N2QFs9Jwy235eP0r+Xp/1EXbN4FdJQ2JiA0R8XAXbU8i24NfFhEbgPOA8fnwyQnA7RHxQET8CbiAbK+y0NyIuC0i/hIRf4yIRyPi4YjYFBHLgf8LfKJomcsi4tWIWAQsBH6Tr3892d70fl3kfTYifhoRfwZuIfsQuDgi3oiI35D9pVM4dj0tz/Q62Yf06xFxQ8Hym9d1APAB4F8j4g8R8XpEPEDX3gR2Bj5QRftxwE8jYmFE/IHsrxvrB1zQm9s6YEgV48FTImKHiHhfRHwyIh4tWH5ohWWnAkMlHQQcDgwE7qiwzHH5+naIiB14515voa8AuwNPSZovaWwXbT9Atle62XPAlmTHDj5A9oEFQERsJHt/hVYUvpC0u6QZklZLepXsOMSQomVeKHj+xxKvt6W84rZERFfLV7uu4cBzVXyQFzoHEPBIfpbROw52F3jbtuTt29wSckFvbnPJ/jQ/rofLzwKOz/e8S8oL461k49OnADfne8A1ERG/j4gTgfcB3wZulbQN79y7hmw8d+eC1yPIxvhfIPtLY9jmGZLeTfYXyNtWV/T6arKx6d3yIZ/zyYpef7cCGNGdA7sRsToiTouIDwD/E/hRF2e2rCL70NhsRM+jWi25oDex/M/+C4AfSjpO0kBJAyQdKemyKrq4HNgeuF7SzgCSdpJ0uaSPFLS7HvgC8DlqfHaLpJMlteXj+K/kk/9CdrDvL2Rj5ZvdBHxN0i752PMlZAf3NpF96Bwt6RBJ7yIbJqhUnLcjO7i5QdKHgNNr9b7q7BGyontpfnrp1pIO7WoBSZ+XtPkD72WyD7fNx05e4O3beQowQdKekgYCF9Y2vvWUC3qTi4jvAv9CdjBtDdne2xnAbVUs+xLZmRdvAvMkvQbMJjsTYmlB0zn5tJURMb+mbwDGAIskbSA7QDo+H9/eCPwf4MF8LP4g4DrgZ3meZ4HXgTPz97Iof34zWbHbQHYmyRtdrPsbwBfJzmD5Mdk4db+Xj6kfTTb+/l/ASrIP3K58jOxnvAGYDpwVEcvyeReRfai/ImlcRNxFdnbNb8l+D35b+3dhPaEI3+DCWk++B/8K2XDKs6nzmNWC99CtZUg6Oh922gb4Dtk59svTpjKrHRd0ayXHkh04/W+y86fHRwv9iSrpmvwSD8WPa1Jns9rwkIuZWZPwHrqZWZNIdgGiIUOGxMiRI7u93Lp12XdBBg8uPoXYzJJbsiT7d4890uZoYo8++ujaiGgrNS9ZQR85ciQdHSWvsNqlyZMnAzBhwoTaBjKz3jv88Ozfe+9NmaKpSSr7zVwPuZiZNYmGu+bzYYcdVrmRmaXxzW+mTtDSGq6gjxo1qnIjM0vjCF9JN6WGG3JZvXo1q1evTh3DzErp7MwelkTD7aHPnDkT8EFRs37p7LOzf31QNImG20M3M7PSqi7okraQ9DtJM0rM20rSLZKWSponaWQtQ5qZWWXd2UM/C1hcZt5XgJcjYleym95+u7fBzMyse6oq6PmF7z8D/KRMk2N568YGtwKjJTXCnV3MzJpGtQdFv0d2z8HtyszfifwegxGxSdJ68hsUFzaSNBGYCDBiRM/uWjV69OgeLWdmtTfy3LffPnb/YdktXxecW/62sssv/UxdM7WyigU9vynvixHxqKTDe7OyiJgETAJob2/v0WUehw8fXrmRmSWxYNiHU0doadUMuRwKHCNpOdntuz4p6edFbZ4nv2lsfmPaQbzzjuo1sWLFClasWFG5oZn1uf1XLmb/leUOtVm9VSzoEXFeRAyLiJHAeOC3EXFyUbPpwJfz5yfkbepyofXZs2cze/bsenRtZr10zpzrOWdOTe8Tbt3Q4y8WSboY6IiI6cC1wM8kLQVeIiv8ZmbWh7pV0CPiXuDe/PkFBdNfBz5fy2BmZtY9/qaomVmTcEE3M2sSDXdxrjFjxqSOYGZlXDx6YuoILa3hCvqOO+6YOoKZlfHk+32/gpQabshl2bJlLFu2LHUMMyvh0OWdHLrc10NPpeH20OfMmQP4zkVm/dGZD90MwIMj902cpDU13B66mZmV5oJuZtYkXNDNzJqEC7qZWZNouIOiY8eOTR3BzMo4/9NnpI7Q0hquoA8ZMiR1BDMrY9ngYakjtLSGG3JZsmQJS5YsSR3DzEoYvXQeo5fOSx2jZTXcHvrcuXMB2GOPPRInMbNipz0yDYDZux6YOElrarg9dDMzK80F3cysSVQs6JK2lvSIpMckLZL0HyXaTJC0RlJn/ji1PnHNzKycasbQ3wA+GREbJA0AHpB0V0Q8XNTulojwOUtmZolULOj5zZ435C8H5I+63AC6Gscff3yqVZtZBV8b+/XUEVpaVWPokraQ1Am8CNwdEaXOS/qcpMcl3SppeE1TFhg0aBCDBg2qV/dm1gurtm9j1fZtqWO0rKoKekT8OSL2BYYBB0jau6jJ7cDIiPgIcDdwfal+JE2U1CGpY82aNT0KvHDhQhYuXNijZc2svsYunsPYxXNSx2hZ3TrLJSJeAe4BxhRNXxcRb+QvfwJ8tMzykyKiPSLa29p69ine0dFBR0dHj5Y1s/o6+Xd3cvLv7kwdo2VVc5ZLm6Qd8ufvBj4FPFXUZmjBy2OAxbUMaWZmlVVzlstQ4HpJW5B9AEyJiBmSLgY6ImI68M+SjgE2AS8BE+oV2MzMSqvmLJfHgf1KTL+g4Pl5wHm1jWZmZt3hb4qamTWJhrs417hx41JHMLMyTj/Of6in1HAFfeDAgakjmFkZLw/0d0RSarghl87OTjo7O1PHMLMSTnhiFic8MSt1jJblgm5mNeOCnlbDFXQzMyvNBd3MrEm4oJuZNQkXdDOzJtFwpy2edNJJqSOYWRkTPn9R6ggtreEK+oABA1JHMLMyXh+wdeoILa3hhlzmz5/P/PnzU8cwsxJOXnAHJy+4I3WMltVwBX3RokUsWrQodQwzK2HsU/cz9qn7U8doWQ1X0M3MrDQXdDOzJuGCbmbWJFzQzcyaRMXTFiVtDcwBtsrb3xoRFxa12Qq4gezm0OuAL0TE8pqnBSZMmFCPbs2sBsZ/8dLUEVpaNXvobwCfjIh9gH2BMZIOKmrzFeDliNgVuAL4dm1jmplZJRULemQ25C8H5I8oanYscH3+/FZgtCTVLGWBhx56iIceeqgeXZtZL502byqnzZuaOkbLqmoMXdIWkjqBF4G7I2JeUZOdgBUAEbEJWA8MLtHPREkdkjrWrFnTo8BPP/00Tz/9dI+WNbP6Gv3MI4x+5pHUMVpWVQU9Iv4cEfsCw4ADJO3dk5VFxKSIaI+I9ra2tp50YWZmZXTrLJeIeAW4BxhTNOt5YDiApC2BQWQHR83MrI9ULOiS2iTtkD9/N/Ap4KmiZtOBL+fPTwB+GxHF4+xmZlZH1VxtcShwvaQtyD4ApkTEDEkXAx0RMR24FviZpKXAS8D4egX21RbN+q/Xt9wqdYSWplQ70u3t7dHR0ZFk3WZWGyPP7f6VFZdf+pk6JGkdkh6NiPZS8/xNUTOzJtFwBf2+++7jvvvuSx3DzEo488GbOPPBm1LHaFkNV9CfffZZnn322dQxzKyEQ597jEOfeyx1jJbVcAXdzMxKc0E3M2sSLuhmZk2imvPQ+5WBAwemjmBmZbz87u1TR2hpDVfQx40blzqCmZVx+vHnp47Q0jzkYmbWJBquoM+aNYtZs2aljmFmJZxz32TOuW9y6hgtq+GGXFauXJk6gpmVsf/zxdfts77UcHvoZmZWmgu6mVmTcEE3M2sSDTeGvv32Ps/VrL9atd2Q1BFaWsMV9M9+9rOpI5hZGV87+hupI7Q0D7mYmTWJau4pOlzSPZKelLRI0lkl2hwuab2kzvxxQX3iwsyZM5k5c2a9ujezXrhg1iQumDUpdYyWVc2Qyybg6xGxQNJ2wKOS7o6IJ4va3R8RY2sf8e1Wr15d71WYWQ/t+eKy1BFaWsU99IhYFREL8uevAYuBneodzMzMuqdbY+iSRgL7AfNKzD5Y0mOS7pK0V5nlJ0rqkNSxZs2aboc1M7Pyqi7okrYFfgWcHRGvFs1eAOwcEfsAVwK3leojIiZFRHtEtLe1tfU0s5mZlVDVaYuSBpAV8xsjYmrx/MICHxF3SvqRpCERsbZ2UTODBw+udZdmViPL3uvR2JQqFnRJAq4FFkfE5WXa7Ai8EBEh6QCyPf91NU2aO/roo+vRrZnVwPljzkwdoaVVs4d+KHAK8ISkznza+cAIgIi4BjgBOF3SJuCPwPiIiDrkNTOzMioW9Ih4AFCFNlcBV9UqVFduv/12wHvqZv3RJTOvBLynnkrDffV/3bq6jOSYWQ2Meun51BFamr/6b2bWJFzQzcyahAu6mVmTaLgx9B133DF1BDMr48n3jUodoaU1XEEfM2ZM6ghmVsbFR0xMHaGlecjFzKxJNFxBnzp1KlOnvuPqA2bWD1xx+3e44vbvpI7RshpuyOXVV4uvC2Zm/cXQ12p++SbrhobbQzczs9Jc0M3MmoQLuplZk2i4MfRhw4aljmBmZSzY6UOpI7S0hivoRxxxROoIZlbGZZ+YkDpCS/OQi5lZk2i4gj5lyhSmTJmSOoaZlXD1tEu4etolqWO0rIYbctm4cWPqCGZWxnv+6O+JpFRxD13ScEn3SHpS0iJJZ5VoI0k/kLRU0uOS9q9PXDMzK6eaPfRNwNcjYoGk7YBHJd0dEU8WtDkS2C1/HAhcnf9rZmZ9pOIeekSsiogF+fPXgMXATkXNjgVuiMzDwA6ShtY8rZmZldWtMXRJI4H9gHlFs3YCVhS8XplPW1W0/ERgIsCIESO6lzS3yy679Gg5s0Y28tw76r6O5Zd+ptd9PLjzPjVI8k49ef+1eD+NpuqCLmlb4FfA2RHRoyMfETEJmATQ3t4ePenjE5/4RE8WM7M+cOWhJ6aO0NKqOm1R0gCyYn5jRJS6du3zwPCC18PyaWZm1keqOctFwLXA4oi4vEyz6cCX8rNdDgLWR8SqMm175cYbb+TGG2+sR9dm1kuTp1zI5CkXpo7RsqoZcjkUOAV4QlJnPu18YARARFwD3AkcBSwFNgL/UPuomTfffLNeXZtZL2296Y3UEVpaxYIeEQ8AqtAmgK/WKpSZmXVfw33138zMSnNBNzNrEg13LZfdd989dQQzK2P2Bw9IHaGlNVxBP+SQQ1JHMLMyfnzgZ1NHaGkecjEzaxINV9AnT57M5MmTU8cwsxJu/sW53PyLc1PHaFkNV9DNzKw0F3Qzsybhgm5m1iRc0M3MmkTDnba41157pY5gZmXM+NDfpY7Q0hquoH/sYx9LHcHMyvj5/q13U4n+pOGGXN58801fcdGsn9r6zdfZ+s3XU8doWQ1X0H09dLP+a/IvL2LyLy9KHaNlNVxBNzOz0lzQzcyahAu6mVmTqOaeotdJelHSwjLzD5e0XlJn/rig9jHNzKySak5bnAxcBdzQRZv7I2JsTRJVsO+++/bFasysB2792yNSR2hp1dxTdI6kkfWPUh0XdLP+ywU9rVqNoR8s6TFJd0kq+1VOSRMldUjqWLNmTY9WtHHjRjZu3NjjoGZWP+/ZuJ73bFyfOkbLqkVBXwDsHBH7AFcCt5VrGBGTIqI9Itrb2tp6tLIpU6YwZcqUniU1s7q6+rZvcfVt30odo2X1uqBHxKsRsSF/ficwQNKQXiczM7Nu6XVBl7SjJOXPD8j7XNfbfs3MrHsqHhSVdBNwODBE0krgQmAAQERcA5wAnC5pE/BHYHxERN0Sm5lZSdWc5XJihflXkZ3WaGZmCTXc5XPb29tTRzCzMn6+31GpI7S0hivoe++9d+oIZlbGjA8fljpCS2u4a7msX7+e9et9nqtZfzT01TUMfbVn3zGx3mu4gj5t2jSmTZuWOoaZlXDFjO9yxYzvpo7RshquoJuZWWku6GZmTcIF3cysSbigm5k1iYY7bfHggw9OHcHMyvjxAcenjtDSGq6g77HHHqkjmFkZs3c9MHWEltZwQy5r165l7dq1qWOYWQmj1q1k1LqVqWO0rIYr6DNmzGDGjBmpY5hZCZf8+iou+bUv7ZRKwxV0MzMrzQXdzKxJuKCbmTUJF3QzsybRcKctHnaYL89p1l9decj41BFaWjW3oLsOGAu8GBHvuBh5fj/R7wNHARuBCRGxoNZBNxs1alS9ujazXnpw5L6pI7S0aoZcJgNjuph/JLBb/pgIXN37WOWtXr2a1atX13MVZtZDe76wjD1fWJY6RsuqWNAjYg7wUhdNjgVuiMzDwA6ShtYqYLGZM2cyc+bMenVvZr1wwexJXDB7UuoYLasWY+g7ASsKXq/Mp60qbihpItlePCNGjKjBqs0az8hz70gdoaS+ytWf17P80s/02/VUo0/PcomISRHRHhHtbW1tfblqM7OmV4uC/jwwvOD1sHyamZn1oVoU9OnAl5Q5CFgfEe8YbjEzs/qq5rTFm4DDgSGSVgIXAgMAIuIa4E6yUxaXkp22+A/1CgswevToenZvZr1w2WFfTh2hpVUs6BFxYoX5AXy1ZokqGD58eOVGZpbEgmEfTh2hpTXcV/9XrFjBihUrKjc0sz63/8rF7L9yceoYLavhCvrs2bOZPXt26hhmVsI5c67nnDnXp47RshquoJuZWWku6GZmTcIF3cysSbigm5k1iYa7HvqYMV1d+NHMUrp49MTUEVpawxX0HXfcMXUEMyvjyff7fgUpNdyQy7Jly1i2zNdbNuuPDl3eyaHLO1PHaFkNt4c+Z84cwHcuMuuPznzoZsB3Lkql4fbQzcysNBd0M7Mm4YJuZtYkXNDNzJpEwx0UHTt2bOoIZlbG+Z8+I3WEltZwBX3IkCGpI5hZGcsGD0sdoaU13JDLkiVLWLJkSeoYZlbC6KXzGL10XuoYLauqgi5pjKQlkpZKOrfE/AmS1kjqzB+n1j5qZu7cucydO7de3ZtZL5z2yDROe2Ra6hgtq5p7im4B/BD4FLASmC9pekQ8WdT0lojwAJqZWSLV7KEfACyNiGUR8SfgZuDY+sYyM7Puqqag7wQU3sRzZT6t2OckPS7pVkkl7+QsaaKkDkkda9as6UFcMzMrp1YHRW8HRkbER4C7gZI3FYyISRHRHhHtbW1tNVq1mZlBdactPg8U7nEPy6f9VUSsK3j5E+Cy3kcr7fjjj69X12bWS18b+/XUEVpaNQV9PrCbpF3ICvl44IuFDSQNjYhV+ctjgMU1TVlg0KBB9erazHpp1fb+yzuligU9IjZJOgP4NbAFcF1ELJJ0MdAREdOBf5Z0DLAJeAmYUK/ACxcuBGDvvfeu1yrMrIfGLs4ubz3jw4clTtKaqvqmaETcCdxZNO2CgufnAefVNlppHR0dgAu6WX908u+yMuGCnkbDfVPUzMxKc0E3M2sSLuhmZk3CBd3MrEk03OVzx40blzqCmZVx+nF9cm6EldFwBX3gwIGpI5hZGS8P9PdEUmq4IZfOzk46OztTxzCzEk54YhYnPDErdYyW5YJuZjXjgp5WwxV0MzMrzQXdzKxJuKCbmTUJF3QzsybRcKctnnTSSakjmFkZEz5/UeoILa3hCvqAAQNSRzCzMl4fsHXqCC2t4YZc5s+fz/z581PHMLMSTl5wBycvuCN1jJbVcAV90aJFLFq0KHUMMyth7FP3M/ap+1PHaFkNV9DNzKy0qgq6pDGSlkhaKuncEvO3knRLPn+epJG1DmpmZl2rWNAlbQH8EDgS2BM4UdKeRc2+ArwcEbsCVwDfrnVQMzPrWjV76AcASyNiWUT8CbgZOLaozbHA9fnzW4HRklS7mGZmVokiousG0gnAmIg4NX99CnBgRJxR0GZh3mZl/vqZvM3aor4mAhPzl3sAS3qYewiwtmKrtPp7RufrHefrHefruZ0joq3UjD49Dz0iJgGTetuPpI6IaK9BpLrp7xmdr3ecr3ecrz6qGXJ5Hhhe8HpYPq1kG0lbAoOAdbUIaGZm1ammoM8HdpO0i6R3AeOB6UVtpgNfzp+fAPw2Ko3lmJlZTVUccomITZLOAH4NbAFcFxGLJF0MdETEdOBa4GeSlgIvkRX9eur1sE0f6O8Zna93nK93nK8OKh4UNTOzxuBvipqZNQkXdDOzJpGsoPfmcgKSzsunL5H06Up95gd05+XTb8kP7vZpPknDJd0j6UlJiySdVdD+IknPS+rMH0cl2n7LJT2RZ+gomP5eSXdL+n3+73sSbL89CrZPp6RXJZ3d19tP0uD857hB0lVFy3w0335LJf1Ayr5c15fbr1w+SQMl3SHpqfz379KCeRMkrSnYfqcm2n735n1uzvG+rvpKsA23K/odXCvpez3dhnUREX3+IDu4+gwwCngX8BiwZ1GbfwKuyZ+PB27Jn++Zt98K2CXvZ4uu+gSmAOPz59cApyfINxTYP2+zHfB0Qb6LgG+k3H75vOXAkBLruww4N39+LvDtFPmK+l9N9gWLvt5+2wAfB/4XcFXRMo8ABwEC7gKOTLD9SuYDBgJ/nz9/F3B/Qb4Jxe8l0fa7F2gvsb6SfaXIWLT8o8BhPdmG9Xqk2kPvzeUEjgVujog3IuJZYGneX8k+82U+mfdB3udxfZ0vIlZFxAKAiHgNWAzsVCFHn+WrsL7CvpJsv6JlRwPPRMRzFXLUPF9E/CEiHgBeL2wsaSiwfUQ8HNn/8Bt4azv12fYrly8iNkbEPfnzPwELyL5T0hM1z1dBTy4tUteMknYH3kf2wdhvpCroOwErCl6v5J3F7a9tImITsB4Y3MWy5aYPBl7J+yi3rr7I91f5n3b7AfMKJp8h6XFJ11XxJ3m98gXwG0mPKrtMw2bvj4hV+fPVwPsT5dtsPHBT0bS+2n5d9bmyTJ99uf0qkrQDcDQwu2Dy5/Ltd6uk4WUW7Yt8P82HLP69oGj3pK+6bkPe2qMvPE2wO9uwLnxQtI9J2hb4FXB2RLyaT74a+CCwL7AK+G6ieB+PiP3Jrqz5VUmHFTfIf4GTneuq7PjHMcAvCyb3l+1XUT/YfluSfRj+ICKW5ZNvB0ZGxEeAu3lrr7WvnRQRfwv8Xf44JVGOahTvVPSLbZiqoPfmcgLlli03fR2wQ95HuXX1RT4kDSAr5jdGxNTNDSLihYj4c0T8BfgxlYdA6pIvIjb/+yIwrSDHC/mQwuahhRdT5MsdCSyIiBc2T+jj7ddVn4VDGIV99uX2q2QS8PuI+N7mCRGxLiLeyF/+BPhoinwFv3+vAb/grZ9jT95r3bahpH2ALSPi0YLs3d2GdZGqoPfmcgLTgfH5EepdgN3IDkaV7DNf5p68D/I+/19f58v/fLwWWBwRlxd2tPk/e+54YGGCfNtI2i7Psw3wPwpyFPaVZPsVLHciRcMtfbz9SsqHVF6VdFD+s/4Sb22nvtx+ZUn6T7KidXbR9MLtdwzZ8Z0+zSdpS0lD8ucDgLGU/v2r9tIi9bxkSaXfwWq2YX3U+ihrtQ/gKLIzPZ4B/i2fdjFwTP58a7I/q5eS/YceVbDsv+XLLSE/Ul+uz3z6qLyPpXmfW/V1PrKj5gE8DnTmj6PyeT8DnsjnTQeGJsg3iuxMgMeARUXbbzDZeOvvgVnAexP9fLch24MaVLSuvt5+y8kucbGBbGx289lK7WRF6BngKt76JnZfb7935CPbQw2yQrP59+/UvP238p/5Y2Q7Px9KkG8bsrNGHs+zfJ+3zr4q21df/4zzecuKt1FPtmE9Hv7qv5lZk/BBUTOzJuGCbmbWJFzQzcyahAu6mVmTcEE3M2sSLuhmZk3CBd3MrEn8f9IF1OvPWWywAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "for c in df_results.columns[:-1]:\n",
    "    if 'mmc' in c:\n",
    "        plt.figure()\n",
    "        plt.title('CPCV Histogram ' + c)\n",
    "        plt.hist(df_results[c])\n",
    "        plt.axvline(0.0, ls = '--', color = 'grey')\n",
    "        plt.axvline(df_results[c].mean(), ls = '--', color = 'red')\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "for c in df_results.columns[:-1]:\n",
    "    plt.figure()\n",
    "    plt.title('CPCV Histogram ' + c)\n",
    "    plt.hist(df_results[c])\n",
    "    plt.axvline(0.0, ls = '--', color = 'grey')\n",
    "    plt.axvline(df_results[c].mean(), ls = '--', color = 'red')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Probability of strategy overfit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "processing split 1 / 20\n",
      "processing split 2 / 20\n",
      "processing split 3 / 20\n",
      "processing split 4 / 20\n",
      "processing split 5 / 20\n",
      "processing split 6 / 20\n",
      "processing split 7 / 20\n",
      "processing split 8 / 20\n",
      "processing split 9 / 20\n",
      "processing split 10 / 20\n",
      "processing split 11 / 20\n",
      "processing split 12 / 20\n",
      "processing split 13 / 20\n",
      "processing split 14 / 20\n",
      "processing split 15 / 20\n",
      "processing split 16 / 20\n",
      "processing split 17 / 20\n",
      "processing split 18 / 20\n",
      "processing split 19 / 20\n",
      "processing split 20 / 20\n",
      "CPU times: user 14min 16s, sys: 21.1 s, total: 14min 37s\n",
      "Wall time: 19min 15s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "N = 6\n",
    "k = 3\n",
    "\n",
    "cpcv = CPCV(dataset, N, k)\n",
    "\n",
    "ALL_P_TESTS_OOS = []\n",
    "ALL_RETURNS_OOS = []\n",
    "ALL_DATES_OOS = []\n",
    "ALL_MMCS_OOS, ALL_PREDS_OOS = [], []\n",
    "FEATURE_IMPORTANCES_OOS = []\n",
    "\n",
    "ALL_P_TESTS_IS = []\n",
    "ALL_RETURNS_IS = []\n",
    "ALL_DATES_IS = []\n",
    "ALL_MMCS_IS, ALL_PREDS_IS = [], []\n",
    "FEATURE_IMPORTANCES_IS = []\n",
    "\n",
    "for e, (train_ids, test_ids) in enumerate(cpcv.split()):\n",
    "    print('processing split', e+1, '/', cpcv.get_n_splits())\n",
    "    \n",
    "    dataset_train, dataset_test = dataset.iloc[train_ids], dataset.iloc[test_ids]\n",
    "    imp, IMPORTANT_FEATURES = calculate_important_features(dataset_train)\n",
    "    \n",
    "    X_train, Y_train, P_train, T_train = createXY(dataset_train[FEATURE_COLUMNS], dataset_train['close'], training=True)\n",
    "    X_test, Y_test, P_test, T_test = createXY(dataset_test[FEATURE_COLUMNS], dataset_test['close'])\n",
    "    \n",
    "    mmcs, pred_prs = train_and_evaluate_n_times(X_train, Y_train, X_test, Y_test)\n",
    "    bagging_strategies, bagging_returns = backtest_predictions(pred_prs, P_test)\n",
    "    \n",
    "    ALL_RETURNS_OOS.append(np.array(bagging_returns))\n",
    "    ALL_P_TESTS_OOS.append(P_test)\n",
    "    ALL_DATES_OOS.append(T_test)\n",
    "    ALL_MMCS_OOS.append(mmcs)\n",
    "    ALL_PREDS_OOS.append(pred_prs)\n",
    "    FEATURE_IMPORTANCES_OOS.append(imp)\n",
    "    \n",
    "    mmcs_is, pred_prs_is = train_and_evaluate_n_times(X_train, Y_train, X_train, Y_train)\n",
    "    bagging_strategies_is, bagging_returns_is = backtest_predictions(pred_prs_is, P_train) \n",
    "    \n",
    "    ALL_RETURNS_IS.append(np.array(bagging_returns_is))\n",
    "    ALL_P_TESTS_IS.append(P_train)\n",
    "    ALL_DATES_IS.append(T_train)\n",
    "    ALL_MMCS_IS.append(mmcs_is)\n",
    "    ALL_PREDS_IS.append(pred_prs_is)\n",
    "    FEATURE_IMPORTANCES_IS.append(imp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_results_is = []\n",
    "for b_ret, s_ret, dates, mmcs, preds, fis in zip(ALL_P_TESTS_IS, \n",
    "                                                 ALL_RETURNS_IS, \n",
    "                                                 ALL_DATES_IS, \n",
    "                                                 ALL_MMCS_IS,\n",
    "                                                 ALL_PREDS_IS,\n",
    "                                                 FEATURE_IMPORTANCES_IS):\n",
    "    res = calculate_all_metrics(\n",
    "            np.array(b_ret), \n",
    "            np.array(s_ret), \n",
    "            [datetime.strptime(date, \"%Y-%m-%d\").date() for date in dates],\n",
    "            mmcs, \n",
    "            fis\n",
    "    )\n",
    "    df_results_is.append(res)\n",
    "df_results_is = pd.DataFrame(df_results_is)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_results_oos = []\n",
    "for b_ret, s_ret, dates, mmcs, preds, fis in zip(ALL_P_TESTS_OOS, \n",
    "                                                 ALL_RETURNS_OOS, \n",
    "                                                 ALL_DATES_OOS, \n",
    "                                                 ALL_MMCS_OOS, \n",
    "                                                 ALL_PREDS_OOS, \n",
    "                                                 FEATURE_IMPORTANCES_OOS):\n",
    "    res = calculate_all_metrics(\n",
    "            np.array(b_ret), \n",
    "            np.array(s_ret), \n",
    "            [datetime.strptime(date, \"%Y-%m-%d\").date() for date in dates],\n",
    "            mmcs, \n",
    "            fis\n",
    "    )\n",
    "    df_results_oos.append(res)\n",
    "df_results_oos = pd.DataFrame(df_results_oos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x147998390>"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "df_results_is['strategy_sharpe'].hist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x145164940>"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWoAAAD4CAYAAADFAawfAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAOjklEQVR4nO3dbYxcZ3nG8evCm4CbNQ7gMKROYEFKkKKsSrqj0AohdlNSpRgFJFAbRFAiASs1AiHVfHAVqVJboYa2RqoEUrEAkb6kG5oSiGLeHPDUosIhuyRkY6ckIVit3dRWWnCZYF62vfthzpL17OzO2Zk5M/eu/j9p5Xl5Zp779plz5fjZMyeOCAEA8nrBqAsAAKyPoAaA5AhqAEiOoAaA5AhqAEhurIo33bVrV0xMTKx6/LnnntNFF11UxZQjQT/5bbWe6Ce/XntaWFh4NiIu6fhkRAz8Z2pqKjo5fPhwx8c3K/rJb6v1RD/59dqTpPlYI1NZ+gCA5AhqAEiOoAaA5AhqAEiOoAaA5AhqAEiu1HnUtk9I+rGk/5W0FBH1KosCADxvI194mYmIZyurBADQEUsfAJCco8T/OMD2DyT9UFJI+mREHOgwZlbSrCTVarWpubm5Ve/TbDY1Pj7eb81pbPZ+Fk+dPe9+bbt0+txw5p7cvXMo82z2bdSOfvLrtaeZmZmFtZaVywb17og4Zfvlkg5J+mBEHFlrfL1ej/n5+VWPNxoNTU9Ply48u83ez8S+g+fd3zu5pP2LlVz+ZZUTd+wZyjybfRu1o5/8eu3J9ppBXWrpIyJOFX+ekXSvpGs3XAUAoCddg9r2RbZ3LN+W9NuSHqu6MABAS5l/59Yk3Wt7efxdEfGVSqsCAPxS16COiKcl/doQagEAdMDpeQCQHEENAMkR1ACQHEENAMkR1ACQHEENAMkR1ACQHEENAMkR1ACQHEENAMkR1ACQHEENAMkR1ACQHEENAMkR1ACQHEENAMkR1ACQHEENAMkR1ACQHEENAMkR1ACQHEENAMkR1ACQHEENAMkR1ACQHEENAMkR1ACQHEENAMkR1ACQHEENAMkR1ACQHEENAMmVDmrb22w/bPv+KgsCAJxvI0fUH5L0eFWFAAA6KxXUti+TtEfSp6otBwDQzhHRfZB9j6Q/k7RD0ocj4q0dxsxKmpWkWq02NTc3t+p9ms2mxsfH+605jc3ez+Kps+fdr22XTp8bztyTu3cOZZ72bdTe87AMqt/N/plrt9X6kXrvaWZmZiEi6p2eG+v2YttvlXQmIhZsT681LiIOSDogSfV6PaanVw9tNBrq9Phmtdn7uXXfwfPu751c0v7Frh+JgTjx7umhzNO+jdp7HpZB9bvZP3Pttlo/UjU9lVn6eIOkG22fkDQn6TrbfzfQKgAAa+oa1BHxhxFxWURMSLpJ0jci4ubKKwMASOI8agBIb0MLkhHRkNSopBIAQEccUQNAcgQ1ACRHUANAcgQ1ACRHUANAcgQ1ACRHUANAcgQ1ACRHUANAcgQ1ACRHUANAcgQ1ACRHUANAcgQ1ACRHUANAcgQ1ACRHUANAcgQ1ACRHUANAcgQ1ACRHUANAcgQ1ACRHUANAcgQ1ACRHUANAcgQ1ACRHUANAcgQ1ACRHUANAcgQ1ACRHUANAcgQ1ACTXNahtv8j2t21/1/Yx2388jMIAAC1jJcb8TNJ1EdG0fYGkb9r+ckQcrbg2AIBKBHVEhKRmcfeC4ieqLAoA8LxSa9S2t9l+RNIZSYci4sFqywIALHPrgLnkYPtiSfdK+mBEPNb23KykWUmq1WpTc3Nzq17fbDY1Pj7eV8GZDKqfxVNnB1BN/2rbpdPnhjPX5O6dQ5mnfRuN6u96UP2yD+XXa08zMzMLEVHv9NyGglqSbP+RpJ9ExF+uNaZer8f8/PyqxxuNhqanpzc0X2aD6mdi38H+ixmAvZNL2r9Y5tcW/Ttxx56hzNO+jUb1dz2oftmH8uu1J9trBnWZsz4uKY6kZXu7pOsl/euGqwAA9KTM4dOlku60vU2tYP9cRNxfbVkAgGVlzvp4VNI1Q6gFANAB30wEgOQIagBIjqAGgOQIagBIjqAGgOQIagBIjqAGgOQIagBIjqAGgOQIagBIjqAGgOQIagBIjqAGgOQIagBIjqAGgOQIagBIjqAGgOQIagBIjqAGgOQIagBIjqAGgOQIagBIjqAGgOQIagBIjqAGgOQIagBIjqAGgOQIagBIjqAGgOQIagBIjqAGgOQIagBIjqAGgOS6BrXty20ftn3c9jHbHxpGYQCAlrESY5Yk7Y2I79jeIWnB9qGIOF5xbQAAlTiijohnIuI7xe0fS3pc0u6qCwMAtDgiyg+2JyQdkXR1RPxP23OzkmYlqVarTc3Nza16fbPZ1Pj4+LpzLJ46W7qeQZrcvXPDrynTTxmj6rldbbt0+tyoqxisLD318vnqpJfPXOZ9alD7UCa99jQzM7MQEfVOz5UOatvjkv5Z0kci4vPrja3X6zE/P7/q8Uajoenp6XXnmdh3sFQ9g3bijj0bfk2ZfsoYVc/t9k4uaf9imdWwzSNLT718vjrp5TOXeZ8a1D6USa892V4zqEud9WH7Akn/JOnvu4U0AGCwypz1YUmflvR4RHys+pIAACuVOaJ+g6T3SLrO9iPFz1sqrgsAUOi6eBcR35TkIdQCAOiAbyYCQHIENQAkR1ADQHIENQAkR1ADQHIENQAkR1ADQHIENQAkR1ADQHIENQAkR1ADQHIENQAkR1ADQHIENQAkR1ADQHIENQAkR1ADQHIENQAkR1ADQHIENQAkR1ADQHIENQAkR1ADQHIENQAkR1ADQHIENQAkR1ADQHIENQAkR1ADQHIENQAkR1ADQHIENQAk1zWobX/G9hnbjw2jIADA+cocUX9W0g0V1wEAWEPXoI6II5L+ewi1AAA6cER0H2RPSLo/Iq5eZ8yspFlJqtVqU3Nzc6vGNJtNjY+PrzvX4qmzXeupwuTunRt+TZl+yhhVz+1q26XT50ZdxWBttZ42Uz9l9qlB7UPtRpkjvfY0MzOzEBH1Ts8NLKhXqtfrMT8/v+rxRqOh6enpdV87se9gmSkG7sQdezb8mjL9lDGqntvtnVzS/sWxUZcxUFutp83UT5l9alD7ULtR5kivPdleM6g56wMAkiOoASC5Mqfn/YOkb0l6re2Ttt9bfVkAgGVdF7si4l3DKAQA0BlLHwCQHEENAMkR1ACQHEENAMkR1ACQHEENAMkR1ACQHEENAMkR1ACQHEENAMkR1ACQHEENAMkR1ACQHEENAMkR1ACQHEENAMkR1ACQHEENAMkR1ACQHEENAMkR1ACQHEENAMkR1ACQHEENAMkR1ACQHEENAMkR1ACQHEENAMkR1ACQHEENAMkR1ACQHEENAMkR1ACQXKmgtn2D7e/Zfsr2vqqLAgA8r2tQ294m6ROSfkfSVZLeZfuqqgsDALSUOaK+VtJTEfF0RPxc0pykt1VbFgBgmSNi/QH2OyXdEBHvK+6/R9LrI+IDbeNmJc0Wd18r6Xsd3m6XpGf7LToR+slvq/VEP/n12tOrIuKSTk+M9VfP8yLigKQD642xPR8R9UHNOWr0k99W64l+8quipzJLH6ckXb7i/mXFYwCAISgT1A9JusL2q21fKOkmSfdVWxYAYFnXpY+IWLL9AUlflbRN0mci4liP8627NLIJ0U9+W60n+slv4D11/WUiAGC0+GYiACRHUANAcpUFte2X2j5k+8niz5esMe6Vtr9m+3Hbx21PVFVTv8r2VIx9se2Ttj8+zBo3okw/tl9n+1u2j9l+1PbvjaLW9XS7xIHtF9q+u3j+wcyfsWUlevqDYn951PbXbb9qFHWWVfYyFLbfYTtspz5lr0w/tn+32EbHbN/V14QRUcmPpD+XtK+4vU/SR9cY15B0fXF7XNKvVFXTsHoqnv8rSXdJ+vio6+6nH0lXSrqiuP2rkp6RdPGoa19R3zZJ35f0GkkXSvqupKvaxtwm6a+L2zdJunvUdQ+gp5nlfUXS72fuqUw/xbgdko5IOiqpPuq6+9w+V0h6WNJLivsv72fOKpc+3ibpzuL2nZLe3j6guGbIWEQckqSIaEbETyqsqV9de5Ik21OSapK+NqS6etW1n4h4IiKeLG7/h6Qzkjp+e2pEylziYGWf90j6LdseYo0b1bWniDi8Yl85qtb3G7IqexmKP5X0UUk/HWZxPSjTz/slfSIifihJEXGmnwmrDOpaRDxT3P5PtYKr3ZWSfmT787Yftv0XxUWgsurak+0XSNov6cPDLKxHZbbRL9m+Vq0jiO9XXdgG7Jb07yvunywe6zgmIpYknZX0sqFU15syPa30XklfrrSi/nTtx/avS7o8Ig4Os7Aeldk+V0q60va/2D5q+4Z+JuzrK+S2H5D0ig5P3b7yTkSE7U7nAY5JeqOkayT9m6S7Jd0q6dP91NWPAfR0m6QvRcTJDAdtA+hn+X0ulfS3km6JiP8bbJXole2bJdUlvWnUtfSqOLj5mFr7/lYxptbyx7Ra/9o5YnsyIn7U65v1LCLevNZztk/bvjQinil28k6H/iclPRIRTxev+YKk39AIg3oAPf2mpDfavk2tNfcLbTcjYiTX8R5AP7L9YkkHJd0eEUcrKrVXZS5xsDzmpO0xSTsl/ddwyutJqcs22H6zWv/BfVNE/GxItfWiWz87JF0tqVEc3LxC0n22b4yI+aFVWV6Z7XNS0oMR8QtJP7D9hFrB/VAvE1a59HGfpFuK27dI+mKHMQ9Jutj28prndZKOV1hTv7r2FBHvjohXRsSEWssffzOqkC6haz/FZQPuVauPe4ZYW1llLnGwss93SvpGFL/hSaprT7avkfRJSTf2u/45BOv2ExFnI2JXREwU+81RtfrKGNJSuc/cF9Q6mpbtXWothTzd84wV/mb0ZZK+LulJSQ9IemnxeF3Sp1aMu17So5IWJX1W0oVV/9a26p5WjL9Vuc/66NqPpJsl/ULSIyt+Xjfq2tv6eIukJ9RaO7+9eOxP1NrZJelFkv5R0lOSvi3pNaOueQA9PSDp9Iptct+oa+6nn7axDSU+66Pk9rFayznHi2y7qZ/5+Ao5ACTHNxMBIDmCGgCSI6gBIDmCGgCSI6gBIDmCGgCSI6gBILn/BwIbsDTmC+pGAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "df_results_oos['strategy_sharpe'].hist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "w_c_is = df_results_is['strategy_sharpe']\n",
    "w_c_oos = df_results_oos['strategy_sharpe']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_star = np.argmax(w_c_is)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1,\n",
       " array([ 9., 12., 17.,  1.,  5.,  3.,  2., 14., 10.,  4., 13., 19.,  8.,\n",
       "        15., 16.,  7., 20.,  6., 18., 11.]))"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n_star, ss.rankdata(w_c_oos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "w_c = (ss.rankdata(w_c_oos) - n_star) / len(w_c_oos)\n",
    "w_c = w_c + np.abs(np.min(w_c))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_c = np.log(w_c / (1 - w_c))\n",
    "y_c[y_c==-np.inf] = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure()\n",
    "plt.hist(y_c)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_c_neg = y_c[y_c < 0]\n",
    "y_c_neg = (y_c_neg - y_c_neg.min()) / (y_c_neg.max() - y_c_neg.min())\n",
    "pbo = np.mean(y_c_neg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6101222487796493"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pbo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "import statsmodels.api as sm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "Y = w_c_oos\n",
    "X = w_c_is\n",
    "X = sm.add_constant(X)\n",
    "model = sm.OLS(Y,X)\n",
    "results = model.fit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table class=\"simpletable\">\n",
       "<caption>OLS Regression Results</caption>\n",
       "<tr>\n",
       "  <th>Dep. Variable:</th>     <td>strategy_sharpe</td> <th>  R-squared:         </th> <td>   0.078</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Model:</th>                   <td>OLS</td>       <th>  Adj. R-squared:    </th> <td>   0.026</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Method:</th>             <td>Least Squares</td>  <th>  F-statistic:       </th> <td>   1.513</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Date:</th>             <td>Sat, 05 Sep 2020</td> <th>  Prob (F-statistic):</th>  <td> 0.234</td> \n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Time:</th>                 <td>13:11:23</td>     <th>  Log-Likelihood:    </th> <td> -1.8859</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>No. Observations:</th>      <td>    20</td>      <th>  AIC:               </th> <td>   7.772</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Df Residuals:</th>          <td>    18</td>      <th>  BIC:               </th> <td>   9.763</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Df Model:</th>              <td>     1</td>      <th>                     </th>     <td> </td>   \n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Covariance Type:</th>      <td>nonrobust</td>    <th>                     </th>     <td> </td>   \n",
       "</tr>\n",
       "</table>\n",
       "<table class=\"simpletable\">\n",
       "<tr>\n",
       "         <td></td>            <th>coef</th>     <th>std err</th>      <th>t</th>      <th>P>|t|</th>  <th>[0.025</th>    <th>0.975]</th>  \n",
       "</tr>\n",
       "<tr>\n",
       "  <th>const</th>           <td>   -0.2942</td> <td>    0.203</td> <td>   -1.447</td> <td> 0.165</td> <td>   -0.721</td> <td>    0.133</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>strategy_sharpe</th> <td>    0.0205</td> <td>    0.017</td> <td>    1.230</td> <td> 0.234</td> <td>   -0.014</td> <td>    0.055</td>\n",
       "</tr>\n",
       "</table>\n",
       "<table class=\"simpletable\">\n",
       "<tr>\n",
       "  <th>Omnibus:</th>       <td> 0.341</td> <th>  Durbin-Watson:     </th> <td>   2.425</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Prob(Omnibus):</th> <td> 0.843</td> <th>  Jarque-Bera (JB):  </th> <td>   0.022</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Skew:</th>          <td> 0.078</td> <th>  Prob(JB):          </th> <td>   0.989</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Kurtosis:</th>      <td> 2.959</td> <th>  Cond. No.          </th> <td>    39.9</td>\n",
       "</tr>\n",
       "</table><br/><br/>Warnings:<br/>[1] Standard Errors assume that the covariance matrix of the errors is correctly specified."
      ],
      "text/plain": [
       "<class 'statsmodels.iolib.summary.Summary'>\n",
       "\"\"\"\n",
       "                            OLS Regression Results                            \n",
       "==============================================================================\n",
       "Dep. Variable:        strategy_sharpe   R-squared:                       0.078\n",
       "Model:                            OLS   Adj. R-squared:                  0.026\n",
       "Method:                 Least Squares   F-statistic:                     1.513\n",
       "Date:                Sat, 05 Sep 2020   Prob (F-statistic):              0.234\n",
       "Time:                        13:11:23   Log-Likelihood:                -1.8859\n",
       "No. Observations:                  20   AIC:                             7.772\n",
       "Df Residuals:                      18   BIC:                             9.763\n",
       "Df Model:                           1                                         \n",
       "Covariance Type:            nonrobust                                         \n",
       "===================================================================================\n",
       "                      coef    std err          t      P>|t|      [0.025      0.975]\n",
       "-----------------------------------------------------------------------------------\n",
       "const              -0.2942      0.203     -1.447      0.165      -0.721       0.133\n",
       "strategy_sharpe     0.0205      0.017      1.230      0.234      -0.014       0.055\n",
       "==============================================================================\n",
       "Omnibus:                        0.341   Durbin-Watson:                   2.425\n",
       "Prob(Omnibus):                  0.843   Jarque-Bera (JB):                0.022\n",
       "Skew:                           0.078   Prob(JB):                        0.989\n",
       "Kurtosis:                       2.959   Cond. No.                         39.9\n",
       "==============================================================================\n",
       "\n",
       "Warnings:\n",
       "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n",
       "\"\"\""
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "results.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAEGCAYAAAB7DNKzAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAcRUlEQVR4nO3df5RdZX3v8feH/GiHnwOSIhkSEyWkpqIETikaUIRg4NaSNLgEqhhar9FakKUQTS4upGhLNBe5XkExVSRUBYTGGIE2BAJYqdBMGCQmGsmNIJnwIwjBolNIwvf+sffgyeGcPWfm/Nhzznxea82as5/9nL2/J4R8z/NjP48iAjMzs0r2yjsAMzMb3pwozMwskxOFmZllcqIwM7NMThRmZpZpdN4B1NvBBx8ckyZNyjsMM7OWsm7dumciYly5c22XKCZNmkR3d3feYZiZtRRJj1U6564nMzPL5ERhZmaZnCjMzCyTE4WZmWVyojAzs0y5JgpJp0raJGmzpIUV6rxX0kZJGyR9p9kxmln7WtHTy4zFa5i88DZmLF7Dip7evEMalnKbHitpFHA1cAqwFVgraWVEbCyqMwVYBMyIiOck/VE+0ZpZu1nR08ui5evp27kbgN4dfSxavh6AOdO78gxt2MmzRXEssDkitkTES8CNwOySOh8Cro6I5wAi4ukmx2hmbWrJqk2vJIl+fTt3s2TVppwiGr7yTBRdwONFx1vTsmJHAEdIuk/S/ZJOLXchSfMldUvq3r59e4PCNbN2sm1H36DKR7LhPpg9GpgCnAicDfyTpM7SShGxNCIKEVEYN67sE+hmZnsY39kxqPKRLM9E0QtMKDo+LC0rthVYGRE7I+KXwC9IEoeZWU0WzJpKx5hRe5R1jBnFgllTc4po+MozUawFpkiaLGkscBawsqTOCpLWBJIOJumK2tLMIM2sPc2Z3sXlc4+kq7MDAV2dHVw+90gPZJeR26yniNgl6TxgFTAKuDYiNki6DOiOiJXpuXdJ2gjsBhZExK/zitnM2suc6V1ODFVQROQdQ10VCoXw6rFmZoMjaV1EFMqdG+6D2WZmljMnCjMzy+REYWZmmZwozMwskxOFmZllcqIwM7NMThRmZpbJicLMzDI5UZiZWSYnCjMzy+REYWZmmZwozMwskxOFmZllcqIwM7NMThRmZpbJicLMzDI5UZiZWSYnCjMzy+REYWZmmZwozMwskxOFmZllcqIwM7NMThRmZpbJicLMzDI5UZiZWaZcE4WkUyVtkrRZ0sKMemdICkmFZsZnZmY5JgpJo4CrgdOAacDZkqaVqbcfcAHwQHMjNDMzyLdFcSywOSK2RMRLwI3A7DL1Pgt8HvjvZgZnZmaJPBNFF/B40fHWtOwVko4GJkTEbVkXkjRfUrek7u3bt9c/UjOzEWzYDmZL2gv4InDhQHUjYmlEFCKiMG7cuMYHZ2Y2guSZKHqBCUXHh6Vl/fYD3gTcI+lR4DhgpQe0zcyaK89EsRaYImmypLHAWcDK/pMR8XxEHBwRkyJiEnA/cHpEdOcTrpnZyJRbooiIXcB5wCrgZ8B3I2KDpMsknZ5XXGZmtqfRed48Im4Hbi8pu6RC3RObEZOZme1p2A5mm5nZ8OBEYWZmmZwozMwskxOFmZllcqIwM7NMThRmZpbJicLMzDI5UZiZWSYnCjMzy5Trk9lm1lpW9PSyZNUmtu3oY3xnBwtmTWXO9K6B32gtzYnCzKqyoqeXRcvX07dzNwC9O/pYtHw9gJNFm3PXk5lVZcmqTa8kiX59O3ezZNWmnCKyZnGiMLOqbNvRN6hyax9OFGZWlfGdHYMqt/bhRGFmVVkwayodY0btUdYxZhQLZk3NKSJrFg9mm1lV+gesPetp5KmYKCR9CLgnIh6RJOBa4AzgUeDciHiwOSGa2XAxZ3rXsE4Mnr7bGFldTxeQJAWAs4E3A5OBTwBfamxYZmaD0z99t3dHH8Hvp++u6OnNO7SWl5UodkXEzvT1u4HrI+LXEXEnsE/jQzMzq56n7zZOVqJ4WdKhkv4QOBm4s+icpzmY2bDi6buNkzWYfQnQDYwCVkbEBgBJ7wC2NCE2M7Oqje/soLdMUig3fddjGYNTsUUREbcCrwPeGBEfKjrVDZzZ6MDMzAaj2um7HssYvIGmxx4E/J2kP0mPNwBfiYinGhuWmdngVDt9N2ssw62K8rKmx84AvgNcB1yfFh8DPCDpfRFxX+PDMzOrXjXTdz2WMXhZLYorgDkR0VNUtlLS94CvAX/W0MjMzBpgMGMZlsia9bR/SZIAICIeAvarx80lnSppk6TNkhaWOf8JSRslPSzpLkmvq8d9zWzk8lIkg5eVKCTpwDKFBw3wvqpIGgVcDZwGTAPOljStpFoPUIiINwO3AF+o9b5mNrLNmd7F5XOPpKuzAwFdnR1cPvdIj09kyOp6uhK4Q9JFQP9yHccAn0/P1epYYHNEbAGQdCMwG9jYXyEi7i6qfz/w/jrc18xGuOG+FMlwUzFRRMRSSduAzwLFs54+FxE/qMO9u4DHi463kj3u8UHgX8udkDQfmA8wceLEOoRmZmb9MqfHps9S3NqkWCqS9H6gALyj3PmIWAosBSgUCtHE0MzM2l7mWIOk0yTdK+mZ9OdeSf+jTvfuBSYUHR+WlpXGMBO4GDg9Il6s073NzKxKAy0z/mHgkyRPY0PyrX6xpMPSb/G1WAtMkTSZJEGcBfxVSQzTSabinhoRT9d4PzMzG4KsrqePA8dHxLNFZWsknQb8iLSrZ6giYpek84BVJOtJXRsRGyRdBnRHxEpgCbAvcHOyJQa/iojTa7mvmZkNTlaiUEmSACAifp3+o12ziLgduL2k7JKi1zPrciMzMxuyrDGK30h6S2lhWvZfjQvJzMyGk6wWxYUkS3Z8E1iXlhWAefh5BjOzESNrmfEfkTwUtxdwbvqzF3Bces7MzEaAgZ6jeIpkAyMzMxuhBtqPwnLmnbjMLG9OFMNY/05c/Zus9O/EBThZmFnTDGoVWEl7Sdq/UcGMFCt6epmxeA2TF97GjMVrKm7BmLUTl5lZswyYKCR9R9L+kvYBfgpslLSg8aG1p8Hs1+uduMxsOKimRTEtIn4DzCFZvXUycE5Do2pjg2klVNpxyztxmVkzVZMoxkgaQ5IoVkbETsArtA7RYFoJ3onLzIaDagazvwY8CvwE+GG6HelvGhlUOxvMfr39A9ae9WTleEacNYsiBt84kDQ6InY1IJ6aFQqF6O7uHrhiTkpnMkHSSvBWjDYY/ntk9SZpXUQUyp2rZjD7AElflNSd/lwB7FP3KEcI79dr9eAZcdZM1XQ9XUsy2+m96fE5wDeBuY0Kqt15v16rlWfEWTNVkyjeEBFnFB3/vaSHGhWQmQ1sMGNd7cZjM81XzaynPknH9x9ImgH4a4tZjkbqjLjBPIdk9VNNi+JvgWWSDgAEPEuykqyZ5WSkzojLGptp98+epwETRUQ8BLylf+mO9OE7M8vZSBzr8thMPiomCknvj4hvSfpESTkAEfHFBsdmZraHkTw2k6esMYr+KbD7lfnZt8FxmZm9ykgdm8lbxRZFRHwtfXlnRNxXfC4d0DYza6qROjaTt2oGs78MHF1FmZlZw43EsZm8ZY1RvBV4GzCuZJxif2BU+XeZmVm7yWpRjCUZixhNMi7R7zfAexoZlJmZDR9ZYxT3AvdKui4iHmtiTGZmNoxU82T27yQtkXS7pDX9P/W4uaRTJW2StFnSwjLn/0DSTen5ByRNqsd9zcysetUkim8DPyfZ2e7vSfamWFvrjSWNAq4GTgOmAWdLmlZS7YPAcxFxOHAl8Pla72tmZoNTTaJ4TUR8A9gZEfdGxN8AJ9Xh3scCmyNiS0S8BNwIzC6pMxtYlr6+BThZ/U/8mZlZU1STKHamv5+Q9OeSpgMH1eHeXcDjRcdb07KyddKNkp4HXlN6IUnz+/fL2L59ex1CMzOzftU8R/G5dEHAC0men9gf+HhDoxqkiFgKLIVkh7ucwzEzayuZiSIdR5gSEbeSfJt/Zx3v3QtMKDo+LC0rV2erpNHAAcCv6xiDmZkNILPrKSJ2A2c36N5rgSmSJksaC5wFrCypsxKYl75+D7AmhrLJt5mZDVk1XU/3SboKuAn4bX9hRDxYy40jYpek84BVJE96XxsRGyRdBnRHxErgG8A/S9pMsg/GWbXc08zMBk8DfUGXdHeZ4oiIesx8qrtCoRDd3d15h2Fm1lIkrYuIQrlz1WxcVM9xCTMzazHVTI81M7MRzInCzMwyOVGYmVmmAccoJO1N8rDdxIj4kKQpwNT02QozM8vZip7ehu76V02L4pvAi8Bb0+Ne4HN1i8DMzIZsRU8vi5avp3dHHwH07uhj0fL1rOgpfX556KpJFG+IiC+QrvkUEb8DvDCfmVmdrOjpZcbiNUxeeBszFq8Z1D/yS1Ztom/n7j3K+nbuZsmqTXWLr5oH7l6S1AEEgKQ3kLQwzMysRv0tgv5/7PtbBEBV3UfbdvQNqnwoqmlRfAb4N2CCpG8DdwGfrFsEZmYjWK0tgvGdHYMqH4pqHrhbLelB4DiSLqcLIuKZukVgZrlo9ACoVafWFsGCWVP3aJEAdIwZxYJZU+sSH1TX9QTwDuB4ku6nMcD36haBmTVdrd0dVj/jOzvoLZMUqm0R9P/3amTSr2Z67FeAw4Eb0qIPS5oZEX9XtyjMrKmyujsalSjcgimvHi2COdO7GvpnWU2L4iTgjf3Le0taBmxoWERm1nDNGAAt5hZMZc1oEdSqmkSxGZgIPJYeT0jLzKxF1drdMVh5tGBaSaNbBLWqZtbTfsDPJN2TLjm+Edhf0kpJpRsNmVkLWDBrKh1jRu1RVu8B0GLNbsFYfVXTorik4VGYWVM1u7uj2S0Yq69q9sy+1HtSmLWfZnZ3NGMKpzVOZqKIiN2SXpZ0QEQ836ygzKy9tMKArVVWTdfTC8B6SavZc8/sjzUsKjNrO8N9wNYqqyZRLE9/zMzqys9WtIZqlvBY1oxAzGxk8bMVrWPA6bGSpki6RdJGSVv6f5oRnJm1r2Ysj231Ue3GRV8FdgHvBK4HvtXIoMys/fnZitZRzRhFR0TcJUkR8RhwqaR1tNnzFe4rNWsuP1vROqppUbwoaS/gEUnnSfpLYN8Gx9VUzdhK0Mz21Oynw23oqkkUFwB7Ax8DjgHOAebVclNJB0laLemR9PeBZeocJenHkjZIeljSmbXcM4v7Ss2ab870Li6feyRdnR0I6Ors4PK5R7olPwxVM+tpbfryBeCv63TfhcBdEbFY0sL0+FMldX4HfCAiHpE0HlgnaVVE7KhTDK9wX6lZPvxsRWuoZj+KI4AFwOuK60fESTXcdzZwYvp6GXAPJYkiIn5R9HqbpKeBcUDdE4X7Ss2sEdpl7LOaweybgWuAfwJ2D1C3WodExBPp6yeBQ7IqSzoWGAv8vwrn5wPzASZOnDjoYLwOjZnVWzs9J1JNotgVEV8d7IUl3Qm8tsypi4sPIiIkRcZ1DgX+GZgXES+XqxMRS4GlAIVCoeK1KvE6NGZWb+20B0fFRCHpoPTlDyR9lGSf7Bf7z0fEs1kXjoiZGdd+StKhEfFEmgierlBvf+A24OKIuD/rfrVyX6mZ1VM7jX1mtSjWAQEoPV5QdC6A19dw35UkM6cWp7+/X1pB0liS5HR9RNxSw73MzJquncY+K06PjYjJEfH69HfpTy1JApIEcYqkR4CZ6TGSCpK+ntZ5L/B24FxJD6U/R9V4XzOzpmin50QUUb5LX9KfAo9HxJPp8QeAM0j2zr50oK6nvBQKheju7s47DDOzlpr1JGldRBTKnstIFA8CMyPiWUlvB24EzgeOAt4YEe9pVMC1cKIwMxu8rESRNUYxqqjVcCawNCL+BfgXSQ/VO8iRppW+aZjZyJaZKCSNjohdwMmkzylU8T4bQDvNr86Tk61Zc2St9XQDcK+k7wN9wL8DSDoc8P7ZNfDaUrXzQo5mzZM16+kfgAuB64Dj4/eDGXuRjFXYELXT/Oq8ONmaNU9mF1K5h9yK12CyoWmn+dV5cbI1a55qlhm3Omun+dV5qZRUnWzN6s+JIgdeh792TrZmzePZS01WOlPnyjOPcoIYAi/kaNY8ThRN5Gmx9eWFHM2aw11PTeSZOmbWipwomsgzdcysFTlRNJFn6phZK3KiaCLP1DGzVuTB7CbyTB0za0VOFE3mmTpm1mrc9WRmZpmcKMzMLJMThZmZZXKiMDOzTE4UZmaWyYnCzMwyOVGYmVkmJwozM8vkRGFmZplySRSSDpK0WtIj6e8DM+ruL2mrpKuaGaOZmSXyalEsBO6KiCnAXelxJZ8FftiUqMzM7FXyShSzgWXp62XAnHKVJB0DHALc0aS4zMysRF6J4pCIeCJ9/SRJMtiDpL2AK4CLBrqYpPmSuiV1b9++vb6RmpmNcA1bPVbSncBry5y6uPggIkJSlKn3UeD2iNgqKfNeEbEUWApQKBTKXcvMzIaoYYkiImZWOifpKUmHRsQTkg4Fni5T7a3ACZI+CuwLjJX0QkRkjWeYmVmd5bUfxUpgHrA4/f390goR8b7+15LOBQpOEmZmzZfXGMVi4BRJjwAz02MkFSR9PaeYzMysDEW0V5d+oVCI7u7uvMMwM2spktZFRKHcOT+ZbWZmmZwozMwskxOFmZllcqIwM7NMThRmZpbJicLMzDI5UZiZWSYnCjMzy+REYWZmmZwozMwskxOFmZllcqIwM7NMThRmZpbJicLMzDI5UZiZWSYnCjMzy5TXVqgjyoqeXpas2sS2HX2M7+xgwaypzJnelXdYZmZVcaJosBU9vSxavp6+nbsB6N3Rx6Ll6wGcLMysJbjrqcGWrNr0SpLo17dzN0tWbcopIjOzwXGLosG27egbVLmZtZaR0LXsFkWDje/sGFS5mbWO/q7l3h19BL/vWl7R05t3aHXlRNFgC2ZNpWPMqD3KOsaMYsGsqTlFZGb1MlK6lt311GD9TdB2b5qajUQjpWvZiaIJ5kzvcmIwa0PjOzvoLZMU2q1r2V1PZmZDNFK6lnNJFJIOkrRa0iPp7wMr1Jso6Q5JP5O0UdKk5kZqZlbZnOldXD73SLo6OxDQ1dnB5XOPbLseBEVE828qfQF4NiIWS1oIHBgRnypT7x7gHyJitaR9gZcj4ndZ1y4UCtHd3d2QuM3M2pWkdRFRKHcur66n2cCy9PUyYE5pBUnTgNERsRogIl4YKEmYmVn95ZUoDomIJ9LXTwKHlKlzBLBD0nJJPZKWSBpVph6S5kvqltS9ffv2RsVsZjYiNWzWk6Q7gdeWOXVx8UFEhKRy/V+jgROA6cCvgJuAc4FvlFaMiKXAUki6nmoK3MzM9tCwRBERMyudk/SUpEMj4glJhwJPl6m2FXgoIrak71kBHEeZRGFmZo2TV9fTSmBe+noe8P0yddYCnZLGpccnARubEJuZmRXJa9bTa4DvAhOBx4D3RsSzkgrARyLif6b1TgGuAASsA+ZHxEsDXHt7es1mOxh4Jof7NoM/W2tq588G7f358vhsr4uIceVO5JIo2pGk7kpTy1qdP1traufPBu39+YbbZ/OT2WZmlsmJwszMMjlR1M/SvANoIH+21tTOnw3a+/MNq8/mMQozM8vkFoWZmWVyojAzs0xOFDWS1CnpFkk/T5dDf2veMdWLpI9L2iDpp5JukPSHecdUC0nXSnpa0k+Lyqpa8n64q/DZlqR/Lx+W9D1JnXnGOFTlPlvRuQslhaSD84itHip9Pknnp//9NqQrbufGiaJ2XwL+LSL+GHgL8LOc46kLSV3Ax4BCRLwJGAWclW9UNbsOOLWkbCFwV0RMAe5Kj1vRdbz6s60G3hQRbwZ+ASxqdlB1ch2v/mxImgC8i2QtuFZ2HSWfT9I7SVbZfktE/Anwv3OI6xVOFDWQdADwdtL1pyLipYjYkW9UdTUa6JA0Gtgb2JZzPDWJiB8Cz5YUD7jkfSso99ki4o6I2JUe3g8c1vTA6qDCfzeAK4FPAi09I6fC5/tbYHFEvJjWKbceXtM4UdRmMrAd+Ga6FPrXJe2Td1D1EBG9JN9ifgU8ATwfEXfkG1VDVLPkfTv4G+Bf8w6iXiTNBnoj4id5x9IgRwAnSHpA0r2S/jTPYJwoajMaOBr4akRMB35L63Zd7CHtq59NkgzHA/tIen++UTVWJHPFW/rbaTmSLgZ2Ad/OO5Z6kLQ38L+AS/KOpYFGAweRrJi9APiuJOUVjBNFbbYCWyPigfT4FpLE0Q5mAr+MiO0RsRNYDrwt55ga4al0qXsylrxvWZLOBd4NvC/a56GpN5B8gfmJpEdJutQelFRu/5tWtRVYHon/BF4mWSgwF04UNYiIJ4HHJU1Ni06mfZZC/xVwnKS9028yJ9MmA/UlqlnyviVJOpWkD//0dtpGOCLWR8QfRcSkiJhE8o/q0en/j+1iBfBOAElHAGPJcaVcJ4ranQ98W9LDwFHAP+YcT12kraRbgAeB9SR/V4bVsgKDJekG4MfAVElbJX0QWAycIukRklbU4jxjHKoKn+0qYD9gtaSHJF2Ta5BDVOGztY0Kn+9a4PXplNkbgXl5tgi9hIeZmWVyi8LMzDI5UZiZWSYnCjMzy+REYWZmmZwozMwskxOFtR1JF6crbj6cTgv9s7T80VZYZVTSiZLeVnT8EUkfqMM1b01fHyLpVkk/kbRR0u21xmztbXTeAZjVU7rM+7tJHsB6MU0MY+tw3dFFC+zVbIDrnQi8APwHQETU+/mHy4DVEfGlNJY31/n61mbcorB2cyjwTNGqm89ERPGqt+dLelDSekl/DCDpWEk/Thd2/I/+J+0lnStppaQ1wF3pt/IfSrpN0iZJ10jaK637rvQaD0q6WdK+pYFJukfS/5HUDVwg6S/SRd96JN2ZftOfBHwE+HjaGjpB0qWSLkqvcZSk+4v2mDgwLf9Y2jp4WNKNVfwZbe0/iIiHh/IHbSOHE4W1mzuACZJ+Iekrkt5Rcv6ZiDga+CpwUVr2c+CEdGHHS9jz6fqjgfdERP91jiV5Gn8ayZpDc9NWy6eBmem1u4FPVIhvbEQUIuIK4EfAcel9bwQ+GRGPAtcAV0bEURHx7yXvvx74VLrHxHrgM2n5QmB6Wv6RAf6Mrga+IenutJtu/AD1bYRz15O1lYh4QdIxwAkka+XcJGlhRFyXVlme/l4HzE1fHwAskzSFZPXYMUWXXB0RxXsF/GdEbIFXll44HvhvksRxX7rA51iSJRnKuano9WFpfIem7/ll1mdL9z/pjIh706JlwM3p64dJlpJZQbJOUEURsUrS60k2yzkN6JH0pojYnvU+G7ncorC2ExG7I+KeiPgMcB5wRtHpF9Pfu/n9F6XPAnenO/n9BVC85etvSy9f5lgkCeWo9GdaRFRaj6j4el8GroqII4EPl9x3sP6cpKVwNLA23Wyqooh4NiK+ExHnAGtJNuAyK8uJwtqKpKlpy6DfUcBjA7ztAKA3fX3uAHWPlTQ5HZs4k6T76H5ghqTD0xj2SVf8HEjxfecVlf8XyWJ+e4iI54HnJJ2QFp0D3JvGMiEi7gY+lV73VWMk/SSdpGRPByTtR9KF1urbiVoDuevJ2s2+wJcldZJs1rMZmD/Ae75A0vX0aeC2AequJVmV9XDgbuB7EfGykn0fbpD0B2m9T5PsU53lUuBmSc8Ba0j2WAD4AXCLkl3czi95zzzgmvQf+i3AX5PsZ/6ttGtKwP8dYEveY4CrJO0i+bL49YhYO0CsNoJ59VizKkk6EbgoIt6ddyxmzeSuJzMzy+QWhZmZZXKLwszMMjlRmJlZJicKMzPL5ERhZmaZnCjMzCzT/wdLcegZrHjzSwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure()\n",
    "plt.scatter(w_c_is, w_c_oos)\n",
    "plt.xlabel('Sharpe ratios IS')\n",
    "plt.ylabel('Sharpe ratios OOS')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
